Prompts

import { prompt, createPrompts } from '@crux/core'

const summarize = prompt({
  id: 'summarize',
  input: z.object({ text: z.string() }),
  output: z.object({ summary: z.string() }),
  system: 'Summarize the text in one sentence.',
  prompt: ({ input }) => input.text,
})

const lookupCustomer = tool({
  description: 'Lookup a customer',
  parameters: z.object({ customerId: z.string() }),
  execute: async ({ customerId }) => {
    return await loadCustomerRecord(customerId)
  },
  toModelOutput: ({ output }) => ({
    type: 'json',
    value: {
      id: output.id,
      plan: output.plan,
      supportTier: output.supportTier,
    },
  }),
})

type ToolModelOutput =
  | { type: 'text'; value: string }
  | { type: 'json'; value: JsonValue }
  | { type: 'execution-denied'; reason?: string }
  | { type: 'error-text'; value: string }
  | { type: 'error-json'; value: JsonValue }
  | { type: 'content'; value: readonly ToolContentPart[] }

const assistant = prompt({
  id: 'assistant',
  use: [
    brandContext,
    userMemory,
    docsGrounding,
    threadBlackboard,
    process.env.NODE_ENV === 'development' && debugContext,
  ],
  input: z.object({
    userId: z.string(),
    question: z.string(),
  }),
  system: 'Answer carefully.',
  prompt: ({ input }) => input.question,
})

import { context, injectable, prompt } from '@crux/core'
import { z } from 'zod'

const accountPlan = injectable({
  id: 'account-plan',
  input: z.object({ accountId: z.string() }),
  async inject({ input }) {
    const plan = await loadAccountPlan(input.accountId)

    return {
      contexts: [
        context({
          id: 'account-plan-context',
          system: `Current account plan: ${plan.name}`,
        }),
      ],
      metadata: {
        accountPlan: plan.name,
      },
    }
  },
})

const support = prompt({
  id: 'support',
  use: [accountPlan],
  input: z.object({
    accountId: z.string(),
    question: z.string(),
  }),
  system: 'Answer using the current account plan.',
  prompt: ({ input }) => input.question,
})

import { contributor, prompt } from '@crux/core'
import { z } from 'zod'

const supportTools = contributor({
  id: 'support-tools',
  input: z.object({ plan: z.string() }),
  // Excluded with a recorded reason when false — visible in .inspect()
  // and devtools. contribute() is never called for excluded entries.
  when: (input) => input.plan !== 'free',
  // Resolved BEFORE this contributor's own contribution.
  use: [docsRetriever.asContext({ topK: 4 })],
  contribute: async ({ input }) => ({
    tools: await loadSupportTools(input.plan),
    metadata: { supportTier: input.plan },
  }),
})

Prompt input = prompt.input & all active context input schemas

const resolved = await assistant.resolve({
  input: { userId: 'user_123', question: 'How do I configure SSO?' },
  tokenBudget: 4000,
})

resolved.system

const rewrite = prompt({
  input: z.object({ text: z.string() }),
  system: 'Rewrite without changing meaning.',
  prompt: ({ input }) => input.text,
})

const reply = prompt({
  input: z.object({ userMessage: z.string() }),
  system: 'You are concise.',
  messages: ({ input }) => [
    { role: 'user', content: 'Answer in one sentence.' },
    { role: 'assistant', content: 'Understood.' },
    { role: 'user', content: input.userMessage },
  ],
})

const textPrompt = prompt({
  system: 'Write a title.',
  prompt: 'A guide to vector search',
})

const objectPrompt = prompt({
  output: z.object({ title: z.string() }),
  system: 'Write a title.',
  prompt: 'A guide to vector search',
})

const extract = prompt({
  id: 'extract',
  output: z.object({ entities: z.array(z.string()) }),
  system: 'Extract named entities.',
  prompt: ({ input }) => input.text,
  adapt: {
    openai: {
      settings: { temperature: 0 },
    },
    anthropic: {
      appendSystem: '\nReturn concise JSON only.',
    },
    '*': {
      settings: { maxTokens: 800 },
    },
  },
})

const resolved = await support.resolve({
  input: { userId: 'user_123', question: 'How do I configure SSO?' },
  provider: 'openai',
  modelId: 'gpt-4o',
})

resolved.system
resolved.prompt
resolved.messages
resolved.tools
resolved.constraints
resolved.guardrails
resolved.metadata
resolved.settings

const inspection = await support.inspect({
  input: { userId: 'user_123', question: 'How do I configure SSO?' },
  tokenBudget: 4000,
})

inspection.system.parts
inspection.droppedContexts
inspection.excludedContexts
inspection.totalTokens

import { compilePrompt, recordingObservability, fixedClock, inMemoryContextCache } from '@crux/core'

const observability = recordingObservability()
const clock = fixedClock(1_000)
const compiled = compilePrompt(config, {
  ports: {
    observability,
    clock,
    cache: inMemoryContextCache(clock),
  },
})

const pass = await compiled.resolve({ input })
const resolved = pass.args
const inspection = pass.inspect()
observability.contributionPreviews('checked-not-included') // exclusions, no transport needed

const prompts = createPrompts({
  editor: {
    rewrite,
    classify,
  },
  support: {
    answerSupport,
  },
})

prompts.editor.rewrite
prompts.support.answerSupport
prompts._all