@noetic-tools/core 0.0.1 → 0.1.1

package/dist/runtime/step-registry.d.ts

@@ -0,0 +1,42 @@
+import type { ContextMemory } from '../types/memory.js';
+import type { Step } from '../types/step.js';
+/** Registry-wide step type — stored at the widest generic parameters so
+ *  callers can register steps with narrower input/output types without
+ *  fighting variance. The public `Step` default already uses `unknown` for
+ *  the input and output parameters, matching this shape. */
+type RegisteredStep = Step<ContextMemory, unknown, unknown>;
+/**
+ * @public
+ * Registers a step so the subprocess adapter can look it up by id.
+ *
+ * Called automatically by the step builders when a `Step` is constructed.
+ * Policy: **latest registration wins**. Dispatch-and-lookup happen in the
+ * same tick, so the live entry is always the one the caller just built;
+ * cross-test pollution from bun's per-file process model (describe blocks
+ * rebuild the same step id) is not a safety concern here. Strict
+ * "reject duplicate id with a different body" detection + a test-side
+ * `clearRegistry` wiring is deferred — see the tracked follow-up task on
+ * the team's board (strict-registry-plus-test-clear).
+ */
+export declare function registerStep<TMemory, I, O>(step: Step<TMemory, I, O>): void;
+/**
+ * @public
+ * Looks up a registered step by id. Returns `null` when the id is not known
+ * — callers (e.g. the in-memory adapter's step dispatch path) translate the
+ * miss into a typed configuration error.
+ */
+export declare function lookupStep(id: string): RegisteredStep | null;
+/**
+ * @public
+ * Returns a read-only view over the registry. Primarily for tests and
+ * debugging; production callers should use `lookupStep`.
+ */
+export declare function getRegistry(): ReadonlyMap<string, RegisteredStep>;
+/**
+ * @public
+ * Clears the registry. Test-only helper — exported because several suites
+ * need a clean registry between describe blocks. Not part of the public API
+ * surface consumed by agent authors.
+ */
+export declare function clearRegistry(): void;
+export {};

package/dist/runtime/step-registry.js

@@ -0,0 +1,77 @@
+import { NoeticConfigError } from '../errors/noetic-config-error.js';
+import { setDefaultRegistrar } from '../types/step-registrar.js';
+import { frameworkCast } from '../util/framework-cast.js';
+//#endregion
+//#region Module state
+const registry = new Map();
+//#endregion
+//#region Public API
+/**
+ * @public
+ * Registers a step so the subprocess adapter can look it up by id.
+ *
+ * Called automatically by the step builders when a `Step` is constructed.
+ * Policy: **latest registration wins**. Dispatch-and-lookup happen in the
+ * same tick, so the live entry is always the one the caller just built;
+ * cross-test pollution from bun's per-file process model (describe blocks
+ * rebuild the same step id) is not a safety concern here. Strict
+ * "reject duplicate id with a different body" detection + a test-side
+ * `clearRegistry` wiring is deferred — see the tracked follow-up task on
+ * the team's board (strict-registry-plus-test-clear).
+ */
+export function registerStep(step) {
+    if (!step.id || step.id.trim() === '') {
+        throw new NoeticConfigError({
+            code: 'EMPTY_STEP_ID',
+            message: 'registerStep() requires a step with a non-empty id.',
+            hint: 'Set `id` on the step before constructing it.',
+        });
+    }
+    // `frameworkCast` is the approved single-point escape for generic variance:
+    // narrowing I/O from specific types to the registry's widened `unknown`
+    // shape is structurally safe at runtime because the registry only holds
+    // references and dispatches them through the same `execute()` pipeline.
+    const widened = frameworkCast(step);
+    registry.set(step.id, widened);
+}
+/**
+ * @public
+ * Looks up a registered step by id. Returns `null` when the id is not known
+ * — callers (e.g. the in-memory adapter's step dispatch path) translate the
+ * miss into a typed configuration error.
+ */
+export function lookupStep(id) {
+    return registry.get(id) ?? null;
+}
+/**
+ * @public
+ * Returns a read-only view over the registry. Primarily for tests and
+ * debugging; production callers should use `lookupStep`.
+ */
+export function getRegistry() {
+    return registry;
+}
+/**
+ * @public
+ * Clears the registry. Test-only helper — exported because several suites
+ * need a clean registry between describe blocks. Not part of the public API
+ * surface consumed by agent authors.
+ */
+export function clearRegistry() {
+    registry.clear();
+}
+//#endregion
+//#region Default-registrar installation
+/**
+ * Install this module's `registerStep` as the runtime default registrar.
+ * Executes on first import — which happens transitively from
+ * `agent-harness.ts` and from anywhere that imports `@noetic-tools/core`'s
+ * top-level barrel. Builders call `getDefaultRegistrar().register(step)`
+ * from `../types/step-registrar` and get this concrete implementation
+ * without depending on `core-runtime` themselves (fixes the
+ * `core-primitives → core-runtime` layer_direction violations).
+ */
+setDefaultRegistrar({
+    register: registerStep,
+});
+//#endregion

package/dist/runtime/tool-memory.d.ts

@@ -1,6 +1,6 @@
 import type { TurnContext } from '@openrouter/agent';
-import type { Context } from '../types/context';
-import type { AgentHarnessContract } from '../types/runtime';
-import type { ToolExecutionContext, ToolMemory } from '../types/tool-context';
+import type { Context } from '../types/context.js';
+import type { AgentHarnessContract } from '../types/runtime.js';
+import type { ToolExecutionContext, ToolMemory } from '../types/tool-context.js';
 export declare function buildToolMemory(harness: AgentHarnessContract, ctx: Context): ToolMemory;
 export declare function buildToolExecutionContext(ctx: Context, harness: AgentHarnessContract, turnContext?: TurnContext): ToolExecutionContext;

package/dist/schemas/item.d.ts

@@ -13,7 +13,7 @@
  * don't need to re-validate every provider field TypeScript already types.
  */
 import { z } from 'zod';
-import type { Item, ItemSchemaExtensions } from '../types/items';
+import type { Item, ItemSchemaExtensions } from '../types/items.js';
 /** @public Structural validator for `Item`. Asserts non-empty string `type` discriminant. */
 export declare const ItemSchema: z.ZodCustom<Item, Item>;
 type ItemSchemaCategory = keyof Required<ItemSchemaExtensions>;

package/dist/schemas/workflow.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Zod schemas for JSON-serialisable workflow definitions.
+ *
+ * A `WorkflowDocument` is a portable, JSON-safe representation of a noetic
+ * step tree. It covers every step kind except `run` (which carries arbitrary
+ * closures). The hydrator in `builders/workflow-hydrator.ts` converts a
+ * validated document back into live `Step` objects via the existing builders.
+ */
+import { z } from 'zod';
+interface UntilAnyPredicate {
+    kind: 'any';
+    predicates: UntilPredicate[];
+}
+interface UntilAllPredicate {
+    kind: 'all';
+    predicates: UntilPredicate[];
+}
+/** @public Discriminated union of named until predicates usable in JSON workflows. */
+export type UntilPredicate = {
+    kind: 'maxSteps';
+    n: number;
+} | {
+    kind: 'maxCost';
+    usd: number;
+} | {
+    kind: 'maxDuration';
+    ms: number;
+} | {
+    kind: 'noToolCalls';
+} | {
+    kind: 'outputContains';
+    marker: string;
+} | {
+    kind: 'outputEquals';
+    sentinel: string;
+} | {
+    kind: 'converged';
+    threshold?: number;
+} | UntilAnyPredicate | UntilAllPredicate;
+/** @public Zod schema validating a named `until` predicate (including `any`/`all` combinators). */
+export declare const UntilPredicateSchema: z.ZodType<UntilPredicate>;
+/** @public ESM literal enum for merge strategies. */
+export declare const MergeStrategy: {
+    readonly Last: "last";
+    readonly First: "first";
+    readonly Concat: "concat";
+};
+/** @public Named merge strategy for fork nodes. */
+export type MergeStrategy = (typeof MergeStrategy)[keyof typeof MergeStrategy];
+/** @public Zod schema for the named merge strategy used by `fork` nodes. */
+export declare const MergeStrategySchema: z.ZodEnum<{
+    concat: "concat";
+    last: "last";
+    first: "first";
+}>;
+declare const ModelParamsSchema: z.ZodObject<{
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+interface WorkflowNodeBase {
+    id: string;
+}
+export interface LlmWorkflowNode extends WorkflowNodeBase {
+    kind: 'llm';
+    model?: string;
+    instructions: string;
+    tools?: string[];
+    params?: z.infer<typeof ModelParamsSchema>;
+}
+export interface ToolWorkflowNode extends WorkflowNodeBase {
+    kind: 'tool';
+    toolName: string;
+    args?: Record<string, unknown>;
+}
+export interface BranchRoute {
+    match: string;
+    target: WorkflowNode;
+}
+export interface BranchWorkflowNode extends WorkflowNodeBase {
+    kind: 'branch';
+    routes: BranchRoute[];
+    default?: WorkflowNode;
+}
+export interface ForkWorkflowNode extends WorkflowNodeBase {
+    kind: 'fork';
+    mode: 'race' | 'all' | 'settle';
+    paths: WorkflowNode[];
+    merge?: MergeStrategy;
+    concurrency?: number;
+}
+export interface SpawnWorkflowNode extends WorkflowNodeBase {
+    kind: 'spawn';
+    child: WorkflowNode;
+    timeout?: number;
+}
+export interface ProvideWorkflowNode extends WorkflowNodeBase {
+    kind: 'provide';
+    child: WorkflowNode;
+    layers: string[];
+}
+export interface LoopWorkflowNode extends WorkflowNodeBase {
+    kind: 'loop';
+    body: WorkflowNode;
+    until: UntilPredicate;
+    maxIterations?: number;
+}
+export interface SequenceWorkflowNode extends WorkflowNodeBase {
+    kind: 'sequence';
+    steps: WorkflowNode[];
+}
+export interface EveryWorkflowNode extends WorkflowNodeBase {
+    kind: 'every';
+    step: WorkflowNode;
+    ms: number;
+    onError?: 'continue' | 'fail';
+}
+/** @public Discriminated union of all JSON-serialisable workflow node kinds. */
+export type WorkflowNode = LlmWorkflowNode | ToolWorkflowNode | BranchWorkflowNode | ForkWorkflowNode | SpawnWorkflowNode | ProvideWorkflowNode | LoopWorkflowNode | SequenceWorkflowNode | EveryWorkflowNode;
+/** @public Zod schema validating a single `WorkflowNode` (any of the 9 JSON-safe kinds). */
+export declare const WorkflowNodeSchema: z.ZodType<WorkflowNode>;
+/** @public Top-level envelope for a JSON workflow definition. */
+export interface WorkflowDocument {
+    version: 1;
+    root: WorkflowNode;
+}
+/** @public Zod schema validating a complete `WorkflowDocument`. */
+export declare const WorkflowDocumentSchema: z.ZodType<WorkflowDocument>;
+/** Validates a candidate workflow document. Throws `ZodError` on invalid input. */
+export declare function validateWorkflow(input: unknown): WorkflowDocument;
+/** Walks a workflow tree depth-first, yielding each node. */
+export declare function walkWorkflow(node: WorkflowNode): Iterable<WorkflowNode>;
+/**
+ * Returns the maximum depth of a workflow tree.
+ * Leaf nodes (`llm`, `tool`) have depth 0. Structural nodes add +1.
+ */
+export declare function workflowDepth(node: WorkflowNode): number;
+export {};

package/dist/schemas/workflow.js

@@ -0,0 +1,232 @@
+/**
+ * Zod schemas for JSON-serialisable workflow definitions.
+ *
+ * A `WorkflowDocument` is a portable, JSON-safe representation of a noetic
+ * step tree. It covers every step kind except `run` (which carries arbitrary
+ * closures). The hydrator in `builders/workflow-hydrator.ts` converts a
+ * validated document back into live `Step` objects via the existing builders.
+ */
+import { z } from 'zod';
+//#endregion
+//#region Until Predicate Schemas
+const MaxStepsPredicateSchema = z.object({
+    kind: z.literal('maxSteps'),
+    n: z.number().int().positive(),
+});
+const MaxCostPredicateSchema = z.object({
+    kind: z.literal('maxCost'),
+    usd: z.number().positive(),
+});
+const MaxDurationPredicateSchema = z.object({
+    kind: z.literal('maxDuration'),
+    ms: z.number().positive(),
+});
+const NoToolCallsPredicateSchema = z.object({
+    kind: z.literal('noToolCalls'),
+});
+const OutputContainsPredicateSchema = z.object({
+    kind: z.literal('outputContains'),
+    marker: z.string().min(1),
+});
+const OutputEqualsPredicateSchema = z.object({
+    kind: z.literal('outputEquals'),
+    sentinel: z.string().min(1),
+});
+const ConvergedPredicateSchema = z.object({
+    kind: z.literal('converged'),
+    threshold: z.number().min(0).max(1).optional(),
+});
+const UntilPredicateRef = z.lazy(() => UntilPredicateSchema);
+const AnyPredicateSchema = z.object({
+    kind: z.literal('any'),
+    predicates: z.array(UntilPredicateRef).min(1),
+});
+const AllPredicateSchema = z.object({
+    kind: z.literal('all'),
+    predicates: z.array(UntilPredicateRef).min(1),
+});
+/** @public Zod schema validating a named `until` predicate (including `any`/`all` combinators). */
+export const UntilPredicateSchema = z.union([
+    MaxStepsPredicateSchema,
+    MaxCostPredicateSchema,
+    MaxDurationPredicateSchema,
+    NoToolCallsPredicateSchema,
+    OutputContainsPredicateSchema,
+    OutputEqualsPredicateSchema,
+    ConvergedPredicateSchema,
+    AnyPredicateSchema,
+    AllPredicateSchema,
+]);
+//#endregion
+//#region Merge Strategy
+/** @public ESM literal enum for merge strategies. */
+export const MergeStrategy = {
+    Last: 'last',
+    First: 'first',
+    Concat: 'concat',
+};
+/** @public Zod schema for the named merge strategy used by `fork` nodes. */
+export const MergeStrategySchema = z.enum([
+    'last',
+    'first',
+    'concat',
+]);
+//#endregion
+//#region Model Params
+const ModelParamsSchema = z.object({
+    temperature: z.number().min(0).optional(),
+    topP: z.number().min(0).max(1).optional(),
+    maxTokens: z.number().int().positive().optional(),
+    stopSequences: z.array(z.string()).optional(),
+});
+//#endregion
+//#region Workflow Node Schema
+const WorkflowNodeRef = z.lazy(() => WorkflowNodeSchema);
+const SHARED_FIELDS = {
+    id: z.string().min(1),
+};
+const LlmNodeSchema = z.object({
+    kind: z.literal('llm'),
+    ...SHARED_FIELDS,
+    model: z.string().optional(),
+    instructions: z.string(),
+    tools: z.array(z.string()).optional(),
+    params: ModelParamsSchema.optional(),
+});
+const ToolNodeSchema = z.object({
+    kind: z.literal('tool'),
+    ...SHARED_FIELDS,
+    toolName: z.string().min(1),
+    args: z.record(z.string(), z.unknown()).optional(),
+});
+const BranchRouteSchema = z.object({
+    match: z.string().min(1),
+    target: z.lazy(() => WorkflowNodeSchema),
+});
+const BranchNodeSchema = z.object({
+    kind: z.literal('branch'),
+    ...SHARED_FIELDS,
+    routes: z.array(BranchRouteSchema).min(1),
+    default: WorkflowNodeRef.optional(),
+});
+const ForkNodeSchema = z.object({
+    kind: z.literal('fork'),
+    ...SHARED_FIELDS,
+    mode: z.enum([
+        'race',
+        'all',
+        'settle',
+    ]),
+    paths: z.array(WorkflowNodeRef).min(1),
+    merge: MergeStrategySchema.optional(),
+    concurrency: z.number().int().positive().optional(),
+});
+const SpawnNodeSchema = z.object({
+    kind: z.literal('spawn'),
+    ...SHARED_FIELDS,
+    child: WorkflowNodeRef,
+    timeout: z.number().positive().optional(),
+});
+const ProvideNodeSchema = z.object({
+    kind: z.literal('provide'),
+    ...SHARED_FIELDS,
+    child: WorkflowNodeRef,
+    layers: z.array(z.string().min(1)).min(1),
+});
+const LoopNodeSchema = z.object({
+    kind: z.literal('loop'),
+    ...SHARED_FIELDS,
+    body: WorkflowNodeRef,
+    until: UntilPredicateSchema,
+    maxIterations: z.number().int().positive().optional(),
+});
+const SequenceNodeSchema = z.object({
+    kind: z.literal('sequence'),
+    ...SHARED_FIELDS,
+    steps: z.array(WorkflowNodeRef).min(1),
+});
+const EveryNodeSchema = z.object({
+    kind: z.literal('every'),
+    ...SHARED_FIELDS,
+    step: WorkflowNodeRef,
+    ms: z.number().nonnegative(),
+    onError: z
+        .enum([
+        'continue',
+        'fail',
+    ])
+        .optional(),
+});
+/** @public Zod schema validating a single `WorkflowNode` (any of the 9 JSON-safe kinds). */
+export const WorkflowNodeSchema = z.discriminatedUnion('kind', [
+    LlmNodeSchema,
+    ToolNodeSchema,
+    BranchNodeSchema,
+    ForkNodeSchema,
+    SpawnNodeSchema,
+    ProvideNodeSchema,
+    LoopNodeSchema,
+    SequenceNodeSchema,
+    EveryNodeSchema,
+]);
+/** @public Zod schema validating a complete `WorkflowDocument`. */
+export const WorkflowDocumentSchema = z.object({
+    version: z.literal(1),
+    root: WorkflowNodeSchema,
+});
+//#endregion
+//#region Helpers
+/** Returns the direct child nodes of a workflow node. Leaf nodes return an empty array. */
+function childNodes(node) {
+    switch (node.kind) {
+        case 'sequence':
+            return node.steps;
+        case 'fork':
+            return node.paths;
+        case 'spawn':
+        case 'provide':
+            return [
+                node.child,
+            ];
+        case 'loop':
+            return [
+                node.body,
+            ];
+        case 'every':
+            return [
+                node.step,
+            ];
+        case 'branch': {
+            const children = node.routes.map((r) => r.target);
+            if (node.default) {
+                children.push(node.default);
+            }
+            return children;
+        }
+        default:
+            return [];
+    }
+}
+/** Validates a candidate workflow document. Throws `ZodError` on invalid input. */
+export function validateWorkflow(input) {
+    return WorkflowDocumentSchema.parse(input);
+}
+/** Walks a workflow tree depth-first, yielding each node. */
+export function* walkWorkflow(node) {
+    yield node;
+    for (const child of childNodes(node)) {
+        yield* walkWorkflow(child);
+    }
+}
+/**
+ * Returns the maximum depth of a workflow tree.
+ * Leaf nodes (`llm`, `tool`) have depth 0. Structural nodes add +1.
+ */
+export function workflowDepth(node) {
+    const children = childNodes(node);
+    if (children.length === 0) {
+        return 0;
+    }
+    return 1 + Math.max(0, ...children.map(workflowDepth));
+}
+//#endregion

package/dist/types/ask-user-types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Wire schemas + types for the ask-user pattern.
+ *
+ * The "ask-user" shape is a portable, tool-agnostic description of an
+ * interactive prompt (questions + options + answers) that any UI — in-process
+ * TUI modal, IPC-backed runner, future web renderer — can render and
+ * respond to. The schemas live in core so callers on either side of an
+ * adapter (tool author, TUI, IPC protocol) validate against the same
+ * definitions rather than each package maintaining a drift-prone copy.
+ *
+ * Kept separate from a concrete tool factory so the TUI can import the
+ * types without pulling in a tool that closes over an `AskUserService`.
+ */
+import { z } from 'zod';
+export declare const AskUserOptionSchema: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodString;
+    preview: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AskUserQuestionSchema: z.ZodObject<{
+    question: z.ZodString;
+    header: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+        preview: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    multiSelect: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const AskUserInputSchema: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        question: z.ZodString;
+        header: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+            preview: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        multiSelect: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const AskUserAnnotationSchema: z.ZodObject<{
+    notes: z.ZodOptional<z.ZodString>;
+    preview: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const AskUserOutputSchema: z.ZodObject<{
+    answers: z.ZodRecord<z.ZodString, z.ZodString>;
+    annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        notes: z.ZodOptional<z.ZodString>;
+        preview: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AskUserOption = z.infer<typeof AskUserOptionSchema>;
+export type AskUserQuestion = z.infer<typeof AskUserQuestionSchema>;
+export type AskUserInput = z.infer<typeof AskUserInputSchema>;
+export type AskUserAnnotation = z.infer<typeof AskUserAnnotationSchema>;
+export type AskUserOutput = z.infer<typeof AskUserOutputSchema>;

package/dist/types/ask-user-types.js

@@ -0,0 +1,74 @@
+/**
+ * Wire schemas + types for the ask-user pattern.
+ *
+ * The "ask-user" shape is a portable, tool-agnostic description of an
+ * interactive prompt (questions + options + answers) that any UI — in-process
+ * TUI modal, IPC-backed runner, future web renderer — can render and
+ * respond to. The schemas live in core so callers on either side of an
+ * adapter (tool author, TUI, IPC protocol) validate against the same
+ * definitions rather than each package maintaining a drift-prone copy.
+ *
+ * Kept separate from a concrete tool factory so the TUI can import the
+ * types without pulling in a tool that closes over an `AskUserService`.
+ */
+import { z } from 'zod';
+//#region Schemas
+export const AskUserOptionSchema = z.object({
+    label: z.string().min(1).describe('The display text for this option. Concise (1–5 words).'),
+    description: z
+        .string()
+        .describe('Explanation of what this option means or what will happen if chosen.'),
+    preview: z
+        .string()
+        .optional()
+        .describe('Optional preview content rendered when this option is focused. Markdown (or HTML fragment) for side-by-side visual comparison.'),
+});
+export const AskUserQuestionSchema = z.object({
+    question: z
+        .string()
+        .min(1)
+        .describe('The complete question. Should be clear, specific, and end with a question mark.'),
+    header: z
+        .string()
+        .min(1)
+        .max(12)
+        .describe('Very short label displayed as a chip/tag (1–12 chars, inclusive).'),
+    options: z
+        .array(AskUserOptionSchema)
+        .min(2)
+        .max(4)
+        .describe('2–4 distinct choices. An "Other" option is added automatically.'),
+    multiSelect: z
+        .boolean()
+        .default(false)
+        .describe('When true, users may select multiple options for this question.'),
+});
+export const AskUserInputSchema = z.object({
+    questions: z
+        .array(AskUserQuestionSchema)
+        .min(1)
+        .max(4)
+        .describe('1–4 questions to ask the user.')
+        // Question text doubles as the answers-map key. Two questions with the
+        // same text would silently collapse, so reject duplicates at parse time.
+        .refine((qs) => new Set(qs.map((q) => q.question)).size === qs.length, {
+        message: 'Question texts must be unique — duplicates would collapse in the answers map.',
+    }),
+});
+export const AskUserAnnotationSchema = z.object({
+    notes: z.string().optional().describe('Free-text notes the user added to their selection.'),
+    preview: z
+        .string()
+        .optional()
+        .describe('The preview content of the selected option, if the question used previews.'),
+});
+export const AskUserOutputSchema = z.object({
+    answers: z
+        .record(z.string(), z.string())
+        .describe('Map from question text to the user\'s answer (label or custom "Other" text).'),
+    annotations: z
+        .record(z.string(), AskUserAnnotationSchema)
+        .optional()
+        .describe('Optional per-question annotations (preview content of selected option, notes).'),
+});
+//#endregion