@code-yeongyu/senpi-agent-core 2026.9.29 → 2026.10.1-2

package/dist/harness/pico3/kinds/entries.d.ts

@@ -0,0 +1,78 @@
+import type { AssistantMessage, ToolResultMessage, UserMessage } from "@earendil-works/pi-ai";
+import type { Entry, EntryKind, Id, JsonValue, SystemMessage, ToolControl } from "../types.ts";
+export type UserEntry = Entry & {
+    kind: "pi.user";
+    model: [UserMessage];
+    data?: {
+        continuation: true;
+        from: Id;
+    };
+};
+export type AssistantEntry = Entry & {
+    kind: "pi.assistant";
+    model: [AssistantMessage];
+    data: {
+        attempt: number;
+    };
+};
+export type ToolResultEntry = Entry & {
+    kind: "pi.tool_result";
+    model: [ToolResultMessage];
+    data: {
+        details?: JsonValue;
+        diagnostics?: JsonValue;
+        control?: ToolControl;
+        truncated?: {
+            bytes: number;
+            lines: number;
+        };
+    };
+};
+export type SystemEntry = Entry & {
+    kind: "pi.system";
+    model: [SystemMessage];
+    data: {
+        baseline: boolean;
+    };
+};
+export type NoticeEntry = Entry & {
+    kind: "pi.notice";
+    model: [UserMessage];
+};
+export type UsageEntry = Entry & {
+    kind: "pi.usage";
+    data: {
+        attempt: number;
+        usage?: AssistantMessage["usage"];
+        error: string;
+    };
+};
+export type SummaryEntry = Entry & {
+    kind: "pi.summary";
+    model: [UserMessage];
+    data: {
+        through: Id;
+    };
+    head: Id;
+};
+export type HandoffEntry = Entry & {
+    kind: "pi.handoff";
+    model: [UserMessage];
+    head: Id;
+};
+export type ResetEntry = Entry & {
+    kind: "pi.reset";
+    head: Id;
+};
+export declare const entries: {
+    readonly user: EntryKind<UserEntry>;
+    readonly assistant: EntryKind<AssistantEntry>;
+    readonly toolResult: EntryKind<ToolResultEntry>;
+    readonly system: EntryKind<SystemEntry>;
+    readonly notice: EntryKind<NoticeEntry>;
+    readonly usage: EntryKind<UsageEntry>;
+    readonly summary: EntryKind<SummaryEntry>;
+    readonly handoff: EntryKind<HandoffEntry>;
+    readonly reset: EntryKind<ResetEntry>;
+};
+//# sourceMappingURL=entries.d.ts.map

package/dist/harness/pico3/kinds/entries.js

@@ -0,0 +1,13 @@
+const coreEntry = (kind) => Object.freeze({ kind, is: (entry) => entry?.kind === kind });
+export const entries = {
+    user: coreEntry("pi.user"),
+    assistant: coreEntry("pi.assistant"),
+    toolResult: coreEntry("pi.tool_result"),
+    system: coreEntry("pi.system"),
+    notice: coreEntry("pi.notice"),
+    usage: coreEntry("pi.usage"),
+    summary: coreEntry("pi.summary"),
+    handoff: coreEntry("pi.handoff"),
+    reset: coreEntry("pi.reset"),
+};
+//# sourceMappingURL=entries.js.map

package/dist/harness/pico3/kinds/frames.d.ts

@@ -0,0 +1,9 @@
+import type { AssistantMessage, AssistantMessageFrame } from "@earendil-works/pi-ai";
+/**
+ * Apply one encoded frame to the tracked output. Same switch as pi-ai's
+ * reduceAssistantMessageFrames (the test oracle); no buffering, no second copy.
+ */
+export declare function applyFrame(o: {
+    message?: AssistantMessage;
+}, frame: AssistantMessageFrame): void;
+//# sourceMappingURL=frames.d.ts.map

package/dist/harness/pico3/kinds/frames.js

@@ -0,0 +1,75 @@
+/**
+ * Apply one encoded frame to the tracked output. Same switch as pi-ai's
+ * reduceAssistantMessageFrames (the test oracle); no buffering, no second copy.
+ */
+export function applyFrame(o, frame) {
+    if (frame.type === "start") {
+        o.message = frame.partial; // the encoder's clone
+        return;
+    }
+    const m = o.message;
+    if (m === undefined)
+        throw new Error(`${frame.type} before start`);
+    const c = m.content;
+    switch (frame.type) {
+        case "text_start":
+            c[frame.contentIndex] = { ...frame.content };
+            return;
+        case "text_delta":
+            c[frame.contentIndex].text += frame.delta;
+            return;
+        case "text_end": {
+            const b = c[frame.contentIndex];
+            b.text = frame.content;
+            delete b.textSignature;
+            if (frame.textSignature !== undefined)
+                b.textSignature = frame.textSignature;
+            return;
+        }
+        case "thinking_start":
+            c[frame.contentIndex] = { ...frame.content };
+            return;
+        case "thinking_delta":
+            c[frame.contentIndex].thinking += frame.delta;
+            return;
+        case "thinking_end": {
+            const b = c[frame.contentIndex];
+            b.thinking = frame.content;
+            delete b.thinkingSignature;
+            delete b.redacted;
+            if (frame.thinkingSignature !== undefined)
+                b.thinkingSignature = frame.thinkingSignature;
+            if (frame.redacted !== undefined)
+                b.redacted = frame.redacted;
+            return;
+        }
+        case "toolcall_start":
+            c[frame.contentIndex] = { ...frame.toolCall };
+            return;
+        case "toolcall_checkpoint":
+            c[frame.contentIndex].arguments = safeParse(frame.json);
+            return;
+        case "toolcall_delta":
+            return; // arguments materialise at checkpoint/end; deltas only feed the encoder's own json buffer
+        case "toolcall_end": {
+            const b = c[frame.contentIndex];
+            b.id = frame.id;
+            b.name = frame.name;
+            b.arguments = frame.arguments;
+            if (frame.thoughtSignature !== undefined)
+                b.thoughtSignature = frame.thoughtSignature;
+            if (frame.namespace !== undefined)
+                b.namespace = frame.namespace;
+            return;
+        }
+    }
+}
+function safeParse(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=frames.js.map

package/dist/harness/pico3/kinds/generation.d.ts

@@ -0,0 +1,94 @@
+import type { Context } from "@earendil-works/chord";
+import type { AssistantMessage, DeferredHandle } from "@earendil-works/pi-ai";
+import { type SystemInstructionsHooks } from "../system.ts";
+import { type CoreKind, type HookInfo, type HookResult, type Id, type ModelRef, type RequestMessage, type RetryPolicy, type Stored, type ThinkingLevel } from "../types.ts";
+export type GenerationInput = {
+    inputs: Id[];
+};
+/** Captured once at `prepared`; carried unchanged except `attempt`. */
+type Prep = {
+    cutoff: Id;
+    system: Id | null;
+    model: ModelRef;
+    thinkingLevel: ThinkingLevel;
+    tools: string[];
+    retry: RetryPolicy;
+    attempt: number;
+};
+export type GenerationCheckpoint = ({
+    phase: "prepared";
+} & Prep) | ({
+    phase: "requesting";
+} & Prep) | ({
+    phase: "retrying";
+    untilMs: number;
+    lastError: string;
+} & Prep) | ({
+    phase: "deferred";
+    handle: Stored<DeferredHandle>;
+    pollAt: number;
+} & Prep);
+export type GenerationResult = {
+    assistant: Id;
+    tools: Id[];
+    postTools?: Id;
+    successor?: Id;
+};
+export type GenerationFailure = {
+    reason: "provider" | "overflow" | "retries_exhausted" | "no_model";
+    detail: string;
+    assistant?: Id;
+};
+/** Display-only assistant entries (provider error, aborted partial) carry the message here, never in `model`. */
+export type DisplayAssistantData = {
+    attempt: number;
+    display: Stored<AssistantMessage>;
+    reason: "error" | "aborted";
+};
+/** Hook points this kind calls. Register with `h.hooks(namespace, kinds.generation, { … })`. */
+export interface GenerationHooks extends SystemInstructionsHooks {
+    /** Before every request (also on retry and recovery). Chain. */
+    beforeRequest(request: {
+        messages: RequestMessage[];
+    }, info: HookInfo & {
+        cutoff: Id;
+    }, ctx: Context): HookResult<{
+        messages: RequestMessage[];
+    }>;
+    /** Every terminal provider message, before classification. Observer. */
+    afterResponse(message: AssistantMessage, info: HookInfo & {
+        attempt: number;
+    }, ctx: Context): void | Promise<void>;
+    /** On a final answer with nothing queued. First `{ continue }` wins and starts a continuation. */
+    onYield(answer: AssistantMessage, info: HookInfo, ctx: Context): HookResult<{
+        continue: string;
+    }>;
+}
+/** Configuration this kind reads, with defaults. `model` has none: absent → failed/no_model. */
+export declare const generationConfig: {
+    readonly rewindable: {
+        readonly model: ModelRef | undefined;
+        readonly thinkingLevel: ThinkingLevel;
+        readonly selectedTools: string[];
+        readonly profile: string;
+    };
+    readonly sticky: {
+        readonly retry: RetryPolicy;
+    };
+};
+export declare const generation: CoreKind<GenerationInput, GenerationCheckpoint, GenerationResult, GenerationFailure, {
+    assistant?: Id;
+}, GenerationHooks, typeof generationConfig>;
+type RetryDecision = {
+    kind: "retry";
+    untilMs: number;
+} | {
+    kind: "fail";
+    reason: "provider" | "retries_exhausted";
+};
+export declare function retryDecision(cp: {
+    retry: RetryPolicy;
+    attempt: number;
+}, message: AssistantMessage | null, now: number): RetryDecision;
+export {};
+//# sourceMappingURL=generation.d.ts.map