@comma-agents/core 2.0.0-rc.0

package/dist/agents/built-in/user/user-agent.types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Context passed to the InputCollector when requesting user input.
+ * Richer than a bare string — provides agent identity and cancellation.
+ */
+export interface InputRequest {
+    /** Name of the agent requesting input. */
+    readonly agentName: string;
+    /** The prompt message to display to the user. */
+    readonly prompt: string;
+    /** Signal for cancellation (e.g., flow was stopped). */
+    readonly signal?: AbortSignal;
+}
+/**
+ * Function that collects input from the user.
+ * The daemon/TUI provides an implementation that bridges to the UI.
+ *
+ * @example
+ * ```ts
+ * // Simple CLI collector
+ * const collector: InputCollector = async ({ prompt }) => {
+ *   return prompt(prompt) ?? "";
+ * };
+ *
+ * // Daemon collector (bridges to WebSocket)
+ * const collector: InputCollector = async ({ agentName, prompt, signal }) => {
+ *   return wsRequestInput(agentName, prompt, signal);
+ * };
+ * ```
+ */
+export type InputCollector = (request: InputRequest) => Promise<string>;
+/** Configuration for creating a user agent. */
+export interface UserAgentConfig {
+    /** Unique name for this agent. */
+    readonly name: string;
+    /**
+     * When true, the agent calls the inputCollector when no incoming message is
+     * available. A non-empty incoming message satisfies the user step directly.
+     * When false, returns `presetMessage` or passes the incoming message through.
+     * @default true
+     */
+    readonly requireInput?: boolean;
+    /**
+     * A preset message to return when `requireInput` is false.
+     * If not set and `requireInput` is false, the incoming message is passed through.
+     */
+    readonly presetMessage?: string;
+    /**
+     * Function that collects input from the user.
+     * Required when `requireInput` is true.
+     * Defaults to reading from stdin via `prompt()`.
+     */
+    readonly inputCollector?: InputCollector;
+}

package/dist/agents/built-in/user/user-agent.utils.d.ts

@@ -0,0 +1,2 @@
+import type { InputCollector } from "./user-agent.types";
+export declare const defaultInputCollector: InputCollector;

package/dist/agents/hook-into-agent/hook-into-agent.d.ts

@@ -0,0 +1,29 @@
+import type { Agent } from "../agent/agent.types";
+import type { AgentHooks, ToolHooks } from "../hooks";
+/**
+ * Append hooks to an existing agent. Mutates the agent in-place.
+ *
+ * Accepts both agent lifecycle hooks (`AgentHooks`) and tool execution
+ * hooks (`ToolHooks`). All hooks are appended to the agent's mutable
+ * internal store, so they take effect on subsequent calls.
+ *
+ * The agent must have been created by `createAgent()` (which provides
+ * the internal `appendHook` method). Throws if the agent doesn't support it.
+ *
+ * @param agent - An agent created by `createAgent()`.
+ * @param hooks - Agent lifecycle and/or tool hooks to append.
+ *
+ * @example
+ * ```ts
+ * const agent = createAgent({ name: "llm", model: "openai/gpt-4o" });
+ *
+ * hookIntoAgent(agent, {
+ *   beforeCall: [async (message) => console.log("calling with:", message)],
+ *   alterResponse: [async (text) => text.toUpperCase()],
+ *   beforeToolCall: [async ({ name, args }) => console.log(`tool: ${name}`)],
+ * });
+ *
+ * const result = await agent.call("hello");
+ * ```
+ */
+export declare function hookIntoAgent(agent: Agent, hooks: AgentHooks & ToolHooks): void;

package/dist/agents/hooks/hooks.types.d.ts

@@ -0,0 +1,64 @@
+import type { SideEffectHook, TransformHook } from "../../hooks";
+import type { ToolContext } from "../../tools/tool.types";
+import type { AgentCallResult, AgentStreamEvent } from "../agent/agent.types";
+/**
+ * Agent lifecycle hooks.
+ *
+ * Execution order for a call:
+ *   alterCallMessage → beforeCall → [LLM call] → afterCallResult → alterResponse
+ *
+ * On the first call, `*First*` variants are used if defined.
+ * If a `*First*` hook is not set, the corresponding base hook is used as fallback.
+ */
+export interface AgentHooks {
+    /** Transform the message before the first call. Falls back to `alterCallMessage`. */
+    readonly alterFirstCallMessage?: ReadonlyArray<TransformHook<string>>;
+    /** Transform the message before subsequent calls. */
+    readonly alterCallMessage?: ReadonlyArray<TransformHook<string>>;
+    /** Side-effect before the first call. Falls back to `beforeCall`. */
+    readonly beforeFirstCall?: ReadonlyArray<SideEffectHook<string>>;
+    /** Side-effect before subsequent calls. */
+    readonly beforeCall?: ReadonlyArray<SideEffectHook<string>>;
+    /**
+     * Side-effect after the first call, receiving the full result including
+     * token usage, finish reason, and response text. Falls back to `afterCallResult`.
+     */
+    readonly afterFirstCallResult?: ReadonlyArray<SideEffectHook<AgentCallResult>>;
+    /**
+     * Side-effect fired after the call completes, receiving the full result
+     * including token usage, finish reason, and response text.
+     *
+     * Fires before `alterResponse`. Use this for token tracking, cost
+     * estimation, analytics, logging, etc.
+     */
+    readonly afterCallResult?: ReadonlyArray<SideEffectHook<AgentCallResult>>;
+    /** Transform the response after the first call. Falls back to `alterResponse`. */
+    readonly alterFirstResponse?: ReadonlyArray<TransformHook<string>>;
+    /** Transform the response after subsequent calls. */
+    readonly alterResponse?: ReadonlyArray<TransformHook<string>>;
+    /**
+     * Called for each streaming event during an agent's LLM call.
+     * Fires when `agent.stream()` is called directly.
+     */
+    readonly onStreamEvent?: ReadonlyArray<SideEffectHook<AgentStreamEvent>>;
+}
+/**
+ * Tool lifecycle hooks.
+ *
+ * Executed around each individual tool invocation within an agent call.
+ */
+export interface ToolHooks {
+    /** Called before a tool is executed. */
+    readonly beforeToolCall?: ReadonlyArray<SideEffectHook<{
+        readonly name: string;
+        readonly args: string;
+        readonly toolContext: ToolContext;
+    }>>;
+    /** Called after a tool is executed. */
+    readonly afterToolCall?: ReadonlyArray<SideEffectHook<{
+        readonly name: string;
+        readonly args: string;
+        readonly result: string;
+        readonly toolContext: ToolContext;
+    }>>;
+}

package/dist/agents/hooks/hooks.utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolve hooks for a given lifecycle point, handling initial vs regular
+ * selection with fallback.
+ *
+ * On the first call (`isFirst = true`), the initial variant is preferred.
+ * If not defined, falls back to the regular variant.
+ * On subsequent calls, the regular variant is always used.
+ */
+export declare function resolveHook<HookType>(initialHooks: ReadonlyArray<HookType> | undefined, regularHooks: ReadonlyArray<HookType> | undefined, isFirst: boolean): ReadonlyArray<HookType> | undefined;

package/dist/agents/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export type { AgentHooks, ToolHooks } from "./hooks.types";
+export { resolveHook } from "./hooks.utils";

package/dist/agents/loader/index.d.ts

@@ -0,0 +1,4 @@
+export { loadAgent, loadAgentFromString } from "./loader";
+export type { AgentDescription } from "./loader.schema";
+export { AgentDescriptionSchema } from "./loader.schema";
+export type { LoadAgentOptions } from "./loader.types";

package/dist/agents/loader/loader.d.ts

@@ -0,0 +1,49 @@
+import type { Agent } from "../agent/agent.types";
+import type { LoadAgentOptions } from "./loader.types";
+/**
+ * Load a single agent from a JSON or YAML description file.
+ *
+ * Auto-detects format by file extension (`.json`, `.yaml`, `.yml`).
+ * Validates the structure, resolves model and tools, and returns a
+ * live `Agent` ready to call.
+ *
+ * @param filePath - Absolute or relative path to the agent description file.
+ * @param options  - Hooks, abort signal.
+ *                   Optional — when omitted, global defaults are used for model resolution.
+ * @returns A live Agent instance.
+ * @throws {StrategyValidationError} If the file is invalid or missing required fields.
+ *
+ * @example
+ * ```ts
+ * import { loadAgent } from "@comma-agents/core";
+ *
+ * // Zero-config — uses global credential store and provider resolver
+ * const agent = await loadAgent("./agents/researcher.yaml");
+ * const result = await agent.call("What is TypeScript?");
+ * ```
+ */
+export declare function loadAgent(filePath: string, options?: LoadAgentOptions): Promise<Agent>;
+/**
+ * Load a single agent from a raw JSON or YAML string.
+ *
+ * Useful when the content is already in memory (e.g., received over
+ * a WebSocket, from a database, or from a test fixture).
+ *
+ * @param content - The raw agent description string.
+ * @param format  - "json" or "yaml".
+ * @param options - Hooks, abort signal.
+ *                  Optional — when omitted, global defaults are used for model resolution.
+ * @returns A live Agent instance.
+ * @throws {StrategyValidationError} If parsing or validation fails.
+ *
+ * @example
+ * ```ts
+ * const yaml = `
+ * name: writer
+ * model: openai/gpt-4o
+ * systemPrompt: You are a creative writer.
+ * `;
+ * const agent = await loadAgentFromString(yaml, "yaml");
+ * ```
+ */
+export declare function loadAgentFromString(content: string, format: "json" | "yaml", _options?: LoadAgentOptions): Promise<Agent>;

package/dist/agents/loader/loader.schema.d.ts

@@ -0,0 +1,270 @@
+import { z } from "zod";
+/**
+ * System prompt template — a Liquid template with optional default variables.
+ *
+ * Mirrors the `systemPromptTemplate` field from the strategy schema but
+ * scoped to a single agent description file.
+ */
+export declare const SystemPromptTemplateSchema: z.ZodObject<{
+    template: z.ZodString;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+}, "strict", z.ZodTypeAny, {
+    template: string;
+    variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+}, {
+    template: string;
+    variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+}>;
+/**
+ * Model-level generation parameters forwarded to `streamText`.
+ *
+ * These are provider-agnostic options supported by virtually every LLM
+ * provider. Provider-specific features (extended thinking, reasoning
+ * effort) should use `providerOptions` instead.
+ */
+export declare const ModelOptionsSchema: z.ZodObject<{
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    topK: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    topK?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    maxRetries?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+    seed?: number | undefined;
+}, {
+    temperature?: number | undefined;
+    topP?: number | undefined;
+    topK?: number | undefined;
+    maxOutputTokens?: number | undefined;
+    maxRetries?: number | undefined;
+    frequencyPenalty?: number | undefined;
+    presencePenalty?: number | undefined;
+    seed?: number | undefined;
+}>;
+/** JSON Schema object used for structured agent output in YAML/JSON files. */
+export declare const OutputSchemaSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/** Serializable conversation context controls for JSON/YAML definitions. */
+export declare const ConversationContextSchema: z.ZodObject<{
+    rollingWindow: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodObject<{
+        maxRecords: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        maxRecords: number;
+    }, {
+        maxRecords: number;
+    }>]>>;
+    compaction: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+        keepRecent: z.ZodOptional<z.ZodNumber>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        keepRecent?: number | undefined;
+        threshold?: number | undefined;
+    }, {
+        keepRecent?: number | undefined;
+        threshold?: number | undefined;
+    }>]>>;
+}, "strict", z.ZodTypeAny, {
+    rollingWindow?: number | {
+        maxRecords: number;
+    } | undefined;
+    compaction?: boolean | {
+        keepRecent?: number | undefined;
+        threshold?: number | undefined;
+    } | undefined;
+}, {
+    rollingWindow?: number | {
+        maxRecords: number;
+    } | undefined;
+    compaction?: boolean | {
+        keepRecent?: number | undefined;
+        threshold?: number | undefined;
+    } | undefined;
+}>;
+/**
+ * Agent description schema — validates a standalone agent description file.
+ *
+ * @example
+ * ```yaml
+ * name: researcher
+ * model: openai/gpt-4o
+ * systemPrompt: You are a research assistant.
+ * tools:
+ *   - read
+ *   - grep
+ * ```
+ */
+export declare const AgentDescriptionSchema: z.ZodObject<{
+    /** Unique name for this agent. */
+    name: z.ZodString;
+    /** Optional human-readable description. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Model string in "providerID/modelID" format (e.g., "openai/gpt-4o"). */
+    model: z.ZodString;
+    /** Static system prompt sent to the model. Mutually exclusive with systemPromptTemplate. */
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    /** Dynamic system prompt using Liquid template syntax. */
+    systemPromptTemplate: z.ZodOptional<z.ZodObject<{
+        template: z.ZodString;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    }, "strict", z.ZodTypeAny, {
+        template: string;
+        variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+    }, {
+        template: string;
+        variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+    }>>;
+    /** Tool names to make available to the agent. */
+    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Per-call provider options forwarded verbatim to the AI SDK. Used to
+     * enable provider-specific features such as Anthropic extended thinking
+     * or OpenAI reasoning effort. Shape:
+     * `{ <providerId>: { <option>: <value>, ... }, ... }`.
+     */
+    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    /** Model-level generation parameters (temperature, maxTokens, etc.). */
+    modelOptions: z.ZodOptional<z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+        presencePenalty: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        topK?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxRetries?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        seed?: number | undefined;
+    }, {
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        topK?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxRetries?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        seed?: number | undefined;
+    }>>;
+    /** JSON Schema describing the agent's structured output. */
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Conversation context retention and compaction controls. */
+    context: z.ZodOptional<z.ZodObject<{
+        rollingWindow: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodObject<{
+            maxRecords: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            maxRecords: number;
+        }, {
+            maxRecords: number;
+        }>]>>;
+        compaction: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+            keepRecent: z.ZodOptional<z.ZodNumber>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        }, {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        rollingWindow?: number | {
+            maxRecords: number;
+        } | undefined;
+        compaction?: boolean | {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        } | undefined;
+    }, {
+        rollingWindow?: number | {
+            maxRecords: number;
+        } | undefined;
+        compaction?: boolean | {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Maximum number of LLM round-trips (steps) per call.
+     * Each tool-call + response counts as one step.
+     */
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    model: string;
+    description?: string | undefined;
+    systemPrompt?: string | undefined;
+    systemPromptTemplate?: {
+        template: string;
+        variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+    } | undefined;
+    tools?: string[] | undefined;
+    providerOptions?: Record<string, Record<string, unknown>> | undefined;
+    modelOptions?: {
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        topK?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxRetries?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        seed?: number | undefined;
+    } | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    context?: {
+        rollingWindow?: number | {
+            maxRecords: number;
+        } | undefined;
+        compaction?: boolean | {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        } | undefined;
+    } | undefined;
+    maxSteps?: number | undefined;
+}, {
+    name: string;
+    model: string;
+    description?: string | undefined;
+    systemPrompt?: string | undefined;
+    systemPromptTemplate?: {
+        template: string;
+        variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+    } | undefined;
+    tools?: string[] | undefined;
+    providerOptions?: Record<string, Record<string, unknown>> | undefined;
+    modelOptions?: {
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        topK?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxRetries?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        seed?: number | undefined;
+    } | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    context?: {
+        rollingWindow?: number | {
+            maxRecords: number;
+        } | undefined;
+        compaction?: boolean | {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        } | undefined;
+    } | undefined;
+    maxSteps?: number | undefined;
+}>;
+export type AgentDescription = z.infer<typeof AgentDescriptionSchema>;

package/dist/agents/loader/loader.types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Options for loading an agent from a description file.
+ *
+ * All fields are optional. Model and tool resolution are handled
+ * internally by `createAgent()` using the global provider registry
+ * (`registerProvider()`), model registry (`registerModel()`), and
+ * tool registry (`registerTool()`).
+ *
+ * @example
+ * ```ts
+ * // Zero-config — uses global credential store and provider resolver
+ * const agent = await loadAgent("./agents/researcher.yaml");
+ * ```
+ */
+export type LoadAgentOptions = Record<never, never>;

package/dist/conversation-context/conversation-context.d.ts

@@ -0,0 +1,78 @@
+import type { ModelMessage } from "ai";
+import type { ContextUsage, ConversationContext, ConversationContextOptions, ConversationRecord, CreateConversationRecordInput } from "./conversation-context.types";
+/**
+ * Create a per-agent conversation context with import/export helpers for
+ * the canonical conversation record contract.
+ *
+ * Optional retention settings run via `prepareForCall` before each call,
+ * transforming the effective history non-destructively. The full record list
+ * is always retained for export.
+ *
+ * @param options - Optional retention configuration.
+ * @example
+ * ```ts
+ * const context = createConversationContext();
+ * context.appendRecord(record);
+ * const messages = context.messages();
+ * ```
+ */
+export declare function createConversationContext(options?: ConversationContextOptions): ConversationContext;
+/**
+ * Build a canonical conversation record from an agent call result.
+ *
+ * @param input - Agent call data used to construct the record.
+ * @example
+ * ```ts
+ * const record = createConversationRecord({
+ *   agentName: "assistant",
+ *   userMessage: "Hello",
+ *   responseMessages: result.responseMessages,
+ *   text: result.text,
+ *   usage: result.usage,
+ *   finishReason: result.finishReason,
+ * });
+ * ```
+ */
+export declare function createConversationRecord(input: CreateConversationRecordInput): ConversationRecord;
+/**
+ * Parse newline-delimited conversation records.
+ *
+ * @param jsonl - JSONL string containing one conversation record per line.
+ * @example
+ * ```ts
+ * const records = parseConversationJsonl(savedContext);
+ * ```
+ */
+export declare function parseConversationJsonl(jsonl: string): readonly ConversationRecord[];
+/** Parse a JSON array of canonical conversation records. */
+export declare function parseConversationJson(json: string): readonly ConversationRecord[];
+/** Serialize conversation records as pretty JSON. */
+export declare function serializeConversationRecordsJson(records: readonly ConversationRecord[]): string;
+/** Parse YAML containing an array of canonical conversation records. */
+export declare function parseConversationYaml(yaml: string): readonly ConversationRecord[];
+/** Serialize conversation records as YAML. */
+export declare function serializeConversationRecordsYaml(records: readonly ConversationRecord[]): string;
+/**
+ * Serialize conversation records to newline-delimited JSON.
+ *
+ * @param records - Conversation records to serialize.
+ * @example
+ * ```ts
+ * const jsonl = serializeConversationRecords(context.records());
+ * ```
+ */
+export declare function serializeConversationRecords(records: readonly ConversationRecord[]): string;
+/**
+ * Serialize a single conversation record to one JSONL line.
+ *
+ * @param record - Conversation record to serialize.
+ * @example
+ * ```ts
+ * const line = recordToJsonlLine(record);
+ * ```
+ */
+export declare function recordToJsonlLine(record: ConversationRecord): string;
+/** Flatten conversation records into the AI SDK message array shape. */
+export declare function recordsToMessages(records: readonly ConversationRecord[]): readonly ModelMessage[];
+/** Return normalized context usage from the final model step. */
+export declare function contextUsageFromSteps(steps: readonly unknown[] | undefined): ContextUsage | undefined;