flavor-code 1.2.1

package/dist/agent/loop.d.ts

@@ -0,0 +1,31 @@
+import type { ContextManager } from "../context/manager.js";
+import type { HallucinationGuard } from "../hallucination/guard.js";
+import type { HookBus } from "../hooks/bus.js";
+import type { ModelRegistry } from "../models/registry.js";
+import { type ModelTool } from "../models/types.js";
+import type { ToolRuntime } from "../tools/runtime.js";
+import type { AgentEvent, AgentRunRequest } from "./types.js";
+export interface AgentLoopOptions {
+    registry: ModelRegistry;
+    modelId: string;
+    fallbackModelId?: string;
+    context: ContextManager;
+    runtime: ToolRuntime;
+    hooks: HookBus;
+    tools: readonly ModelTool[];
+    maxIterations?: number;
+    softLimitFactor?: number;
+    extendIterations?: number;
+    maxExtensions?: number;
+    hasActiveProgress?(): boolean;
+    agent?: "main" | "subagent";
+    hallucinationGuard?: HallucinationGuard;
+}
+export declare class AgentLoop {
+    #private;
+    constructor(options: AgentLoopOptions);
+    get modelId(): string;
+    setModel(modelId: string): void;
+    setFallbackModel(modelId: string): void;
+    run(request: AgentRunRequest): AsyncIterable<AgentEvent>;
+}

package/dist/agent/message-queue.d.ts

@@ -0,0 +1,19 @@
+export type AgentQueueKind = "steer" | "followUp";
+export type AgentQueueMode = "one-at-a-time" | "all";
+export interface AgentQueueSnapshot {
+    steering: readonly string[];
+    followUp: readonly string[];
+}
+export interface AgentMessageQueueOptions {
+    steeringMode?: AgentQueueMode;
+    followUpMode?: AgentQueueMode;
+}
+export declare class AgentMessageQueue {
+    #private;
+    constructor(options?: AgentMessageQueueOptions);
+    get hasPending(): boolean;
+    enqueue(kind: AgentQueueKind, message: string): void;
+    drain(kind: AgentQueueKind): string[];
+    snapshot(): AgentQueueSnapshot;
+    clear(): AgentQueueSnapshot;
+}

package/dist/agent/planner.d.ts

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import type { HookBus } from "../hooks/bus.js";
+export declare const TaskNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    dependencies: z.ZodArray<z.ZodString>;
+    expectedOutputs: z.ZodArray<z.ZodString>;
+    verification: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const TaskGraphSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        expectedOutputs: z.ZodArray<z.ZodString>;
+        verification: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TaskNode = z.infer<typeof TaskNodeSchema>;
+export type TaskGraph = z.infer<typeof TaskGraphSchema>;
+export interface TaskPlannerOptions {
+    hooks: HookBus;
+}
+export declare class TaskPlanner {
+    #private;
+    constructor(options: TaskPlannerOptions);
+    plan(input: unknown, signal?: AbortSignal): Promise<TaskGraph>;
+}

package/dist/agent/subagents.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { HookBus } from "../hooks/bus.js";
+import { type ModelMessage } from "../models/types.js";
+import { type TaskGraph, type TaskNode } from "./planner.js";
+export declare const SubagentResultSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    summary: z.ZodString;
+    filesChanged: z.ZodArray<z.ZodString>;
+    commandsRun: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        summary: z.ZodString;
+    }, z.core.$strict>>;
+    verification: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        passed: z.ZodBoolean;
+        details: z.ZodString;
+    }, z.core.$strict>>;
+    artifacts: z.ZodArray<z.ZodString>;
+    risks: z.ZodArray<z.ZodString>;
+    suggestedNextSteps: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type SubagentResult = z.infer<typeof SubagentResultSchema>;
+export type SubagentState = "pending" | "running" | "completed" | "failed" | "blocked" | "cancelled";
+export interface SubagentExecution {
+    attempt: 1 | 2;
+    signal: AbortSignal;
+}
+export interface SubagentSchedulerOptions {
+    maxSubagents?: number;
+    hooks: HookBus;
+    execute(task: TaskNode, execution: SubagentExecution): Promise<unknown>;
+    onResult?(result: SubagentResult): void | Promise<void>;
+}
+export interface SubagentRunResult {
+    states: Record<string, SubagentState>;
+    results: Record<string, SubagentResult>;
+}
+export declare function subagentResultFromTaskOutput(taskId: string, output: unknown): SubagentResult | undefined;
+export declare function parseFinalSubagentMessage(messages: readonly ModelMessage[]): unknown;
+export declare class SubagentScheduler {
+    #private;
+    constructor(options: SubagentSchedulerOptions);
+    run(input: TaskGraph, externalSignal?: AbortSignal): Promise<SubagentRunResult>;
+}

package/dist/agent/task-plan.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+export declare const PlanTaskStatusSchema: z.ZodEnum<{
+    blocked: "blocked";
+    cancelled: "cancelled";
+    completed: "completed";
+    failed: "failed";
+    in_progress: "in_progress";
+    pending: "pending";
+}>;
+export declare const PlanTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    activeForm: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        in_progress: "in_progress";
+        pending: "pending";
+    }>;
+    dependencies: z.ZodArray<z.ZodString>;
+    result: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const TaskPlanSchema: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        subject: z.ZodString;
+        activeForm: z.ZodString;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            in_progress: "in_progress";
+            pending: "pending";
+        }>;
+        dependencies: z.ZodArray<z.ZodString>;
+        result: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const TaskUpdateInputSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        in_progress: "in_progress";
+        pending: "pending";
+    }>;
+    result: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PlanTaskStatus = z.infer<typeof PlanTaskStatusSchema>;
+export type PlanTask = z.infer<typeof PlanTaskSchema>;
+export type TaskPlan = z.infer<typeof TaskPlanSchema>;
+export type TaskUpdateInput = z.infer<typeof TaskUpdateInputSchema>;
+export declare function updatePlanTask(plan: TaskPlan, input: TaskUpdateInput): TaskPlan;
+export declare function activateNextReadyTask(plan: TaskPlan): TaskPlan;
+export declare function normalizeAbandonedPlan(plan: TaskPlan): TaskPlan;

package/dist/agent/task-tools.d.ts

@@ -0,0 +1,11 @@
+import { type TaskPlan, type TaskUpdateInput } from "./task-plan.js";
+import type { ToolDefinition } from "../tools/types.js";
+export declare const MAIN_TASK_TOOL_NAMES: Set<string>;
+export interface TaskPlanToolOptions {
+    getPlan(): TaskPlan | undefined;
+    commit(plan: TaskPlan, operation: "replace" | "update"): void | Promise<void>;
+}
+export declare function createTaskPlanTools(options: TaskPlanToolOptions): readonly [
+    ToolDefinition<TaskPlan>,
+    ToolDefinition<TaskUpdateInput>
+];

package/dist/agent/types.d.ts

@@ -0,0 +1,117 @@
+import type { ModelMessage, ProviderErrorCode } from "../models/types.js";
+import type { ToolResult } from "../tools/types.js";
+import type { TaskGraph } from "./planner.js";
+import type { SubagentState } from "./subagents.js";
+import type { TaskPlan } from "./task-plan.js";
+export interface AgentRunRequest {
+    prompt: string;
+    /** Optional rich initial user message. Text-only routing continues to use prompt. */
+    initialUserMessage?: Extract<ModelMessage, {
+        role: "user";
+    }>;
+    signal?: AbortSignal;
+    /** Prompt-scoped system context, such as a matched skill body. It is never stored. */
+    additionalContext?: string;
+    /** Messages supplied while a tool batch is running, injected before the next model call. */
+    getSteeringMessages?(): readonly string[];
+}
+export type AgentErrorCode = ProviderErrorCode | "iteration_limit" | "incomplete_stream";
+export interface AgentError {
+    code: AgentErrorCode;
+    message: string;
+}
+export interface TaskSnapshot {
+    plan?: TaskPlan;
+    subagents: {
+        graph?: TaskGraph;
+        states: Record<string, SubagentState>;
+        /** Unix-ms timestamp captured when each subagent transitioned to "running". */
+        startedAt?: Record<string, number>;
+        /** Frozen elapsed-ms captured when each subagent reached a terminal state. */
+        elapsedMs?: Record<string, number>;
+    };
+    foregroundTaskId?: string;
+}
+export type AgentEvent = {
+    type: "model-start";
+    id: string;
+} | {
+    type: "model-end";
+    id: string;
+} | {
+    type: "text";
+    text: string;
+} | {
+    type: "tool-start";
+    id: string;
+    name: string;
+    input: unknown;
+    label?: string;
+    hint?: string;
+} | {
+    type: "tool-end";
+    id: string;
+    name: string;
+    result: ToolResult;
+    label?: string;
+    hint?: string;
+} | {
+    type: "tasks";
+    snapshot: TaskSnapshot;
+} | {
+    type: "tasks-cleared";
+} | {
+    type: "usage";
+    inputTokens: number;
+    outputTokens: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+} | {
+    type: "model-retry";
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+} | {
+    type: "structured-output-retry";
+    tool: string;
+    modelId: string;
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    error: string;
+} | {
+    type: "loop-progress";
+    loopId: string;
+    phase: "resolved" | "cycle" | "verification" | "budget" | "terminal";
+    state: "running" | "completed" | "failed" | "cancelled" | "info";
+    message: string;
+} | {
+    type: "compact-progress";
+    progress: number;
+} | {
+    type: "compacted";
+} | {
+    type: "notice";
+    message: string;
+} | {
+    type: "warning";
+    message: string;
+} | {
+    type: "limit_reached";
+    iteration: number;
+    maxIterations: number;
+    extended: boolean;
+} | {
+    type: "done";
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadTokens?: number;
+        cacheCreationTokens?: number;
+    };
+} | {
+    type: "error";
+    error: AgentError;
+};