zigmini 0.8.0-beta.7 → 0.9.0-beta.2

package/host/omo-check/patches/omo-5.1.44-provider-port.patch

@@ -0,0 +1,440 @@
+--- a/@code-yeongyu/senpi/dist/core/auth-storage.js
++++ b/@code-yeongyu/senpi/dist/core/auth-storage.js
+@@ -344,7 +344,6 @@
+  */
+ export class AuthStorage {
+     constructor(storage, authPath) {
+-        this.data = {};
+         this.runtimeOverrides = new Map();
+         this.extensionOAuthProviders = new Map();
+         this.errors = [];
+@@ -367,14 +366,21 @@
+             // Another instance already loaded this store: start from its credentials, not an
+             // empty snapshot, so a busy read below keeps them. A repaired or migrated load
+             // leaves the revision unset, so only an exact revision match skips the re-read.
+-            this.data = this.readState.data;
+             this.dataLoaded = true;
+             const revision = getFileContentRevision(authPath);
+             if (revision !== undefined && revision === this.readState.revision)
+                 return;
+         }
+         this.reload();
++    }
++    // Synchronous extension reads and async runtime reads share one snapshot.
++    get data() {
++        return this.readState.data;
+     }
++    set data(data) {
++        this.readState.data = data;
++        this.readState.revision = undefined;
++    }
+     static create(authPath = join(getAgentDir(), "auth.json")) {
+         const normalizedAuthPath = normalizePath(authPath);
+         return new AuthStorage(new FileAuthStorageBackend(normalizedAuthPath), normalizedAuthPath);
+@@ -445,7 +451,6 @@
+         return backupPath;
+     }
+     updateReadState(data, revision) {
+-        this.data = data;
+         this.dataLoaded = true;
+         this.dataFromBusyRead = false;
+         this.readState.data = data;
+@@ -897,4 +902,4 @@
+         return undefined;
+     }
+ }
+-//# sourceMappingURL=auth-storage.js.map
+
++//# sourceMappingURL=auth-storage.js.map
+--- a/@code-yeongyu/senpi/dist/core/credential-accounts.js
++++ b/@code-yeongyu/senpi/dist/core/credential-accounts.js
+@@ -75,6 +75,8 @@
+  * here without auth.json ever carrying block state.
+  */
+ export async function getCredentialAccounts(storage, provider, env = process.env, repository) {
++    // Refresh metadata without resolving keys or applying runtime overrides.
++    await storage.list();
+     return summarizeCredentialAccounts(provider, storage.get(provider), env, repository ?? credentialPoolRepository(storage));
+ }
+ /** Storage-free variant for callers that already hold the credential (e.g. auth check). */
+@@ -211,4 +213,4 @@
+     await repo.mutateSlotState(provider, "stored", name, () => undefined);
+     emitProviderAccountsChanged(provider);
+ }
+-//# sourceMappingURL=credential-accounts.js.map
+
++//# sourceMappingURL=credential-accounts.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/auth-lane.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/auth-lane.d.ts
+@@ -20,7 +20,7 @@
+ export type AuthenticatedQueryInput = {
+     prompt: Parameters<SdkQuery>[0]["prompt"];
+     query: SdkQuery;
+-    buildOptions: (lane: AnthropicSubscriptionTokenInjection) => Options;
++    buildOptions: (lane: AnthropicSubscriptionTokenInjection) => Options | Promise<Options>;
+     providerSettings: AnthropicSubscriptionProviderSettings;
+     /** Effective request auth environment; overrides the host for account discovery and SDK spawn. */
+     env?: Record<string, string>;
+@@ -38,4 +38,4 @@
+ export declare function resolveEffectiveLane(settings: AnthropicSubscriptionProviderSettings, accounts: readonly AccountSlot[]): AnthropicSubscriptionTokenInjection;
+ /** Resolves managed OAuth immediately before each subprocess spawn and retries only pre-delta failures. */
+ export declare function queryWithAuthLane(input: AuthenticatedQueryInput): AsyncGenerator<SDKMessage>;
+-//# sourceMappingURL=auth-lane.d.ts.map
+
++//# sourceMappingURL=auth-lane.d.ts.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/auth-lane.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/auth-lane.js
+@@ -145,7 +145,7 @@
+         // Lane-owned variables from buildOptions (the compaction-owner overlay) win over the host.
+         let askedLegacyLongContext = false;
+         const ambientAttempt = async () => {
+-            const options = input.buildOptions("ambient");
++            const options = await input.buildOptions("ambient");
+             askedLegacyLongContext = asksLegacyLongContext(options.model);
+             options.env = { ...ambientEnvironment, ...options.env };
+             return createAttemptMessages(input, { accountName: "ambient", accounts: [], authLane: "ambient", options });
+@@ -184,7 +184,7 @@
+             ...(input.model === undefined ? {} : { model: input.model }),
+         }),
+         runAttempt: async (slot) => {
+-            const options = input.buildOptions(pool.lane);
++            const options = await input.buildOptions(pool.lane);
+             askedLegacyLongContext = asksLegacyLongContext(options.model);
+             const accounts = pool.accounts.map((account) => ({ ...account }));
+             const prepared = await prepareSlot(pool, slot, signal);
+@@ -215,4 +215,4 @@
+         },
+     });
+ }
+-//# sourceMappingURL=auth-lane.js.map
+
++//# sourceMappingURL=auth-lane.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js
+@@ -21,6 +21,7 @@
+     toolOutput: (toolName) => `[image returned by the ${toolName} tool to your own call (tool output, not a user attachment)]`,
+     userHistory: "[image the user attached in this earlier turn (history, not part of the current message)]",
+     duplicate: (origin, first) => `${subject(origin)}: identical to an image already shown above (${source(first)}); not attached again]`,
++    userAnswered: "[image the user attached in an earlier turn: you already saw and answered it, so it is not attached again and is not part of the current message; ask the user to attach it again if you need it]",
+     answered: (origin) => `[image returned earlier by the ${origin.toolName} tool, id=${origin.toolCallId}: already seen earlier in this conversation; run the tool again if you need it]`,
+     capped: (origin) => `${subject(origin)}: omitted from this replay, which re-sends at most ${MAX_REPLAYED_HISTORY_IMAGES} earlier images; re-read the source if you need it]`,
+     unreadable: (origin) => `${subject(origin)}: omitted because its image data is missing or unreadable]`,
+@@ -86,14 +87,16 @@
+     return new Set(ordered.slice(0, MAX_REPLAYED_HISTORY_IMAGES).map(([hash]) => hash));
+ }
+ /**
+- * A tool image the assistant already responded to is not re-sent (#2768): a cold
+- * seed packs the whole history into one user message, and replaying earlier tool
+- * reads there made the model answer plain questions as if the user had just sent
+- * those images. The user's own uploads and images still awaiting a response are
+- * replayed.
++ * An image the assistant already responded to is not re-sent (#2768): a cold
++ * seed packs the whole history into one user message, and replaying earlier
++ * images there made the model answer plain questions as if the user had just
++ * sent those images. zigmini: this covers the user's own earlier uploads too;
++ * Claude Code saved each replayed upload as a new images/N.png on every model
++ * call and the model read it as a new attachment. Images still awaiting a
++ * response (the current turn) are replayed.
+  */
+ function isAnsweredToolImage(occurrence) {
+-    return occurrence.answered && occurrence.origin.kind === "tool";
++    return occurrence.answered;
+ }
+ /**
+  * Rewrites the image entries of a cold-seed history (#2490): a tool-result image
+@@ -124,8 +127,8 @@
+         if (decoded === undefined || hash === undefined) {
+             replacement = [{ type: "text", text: coldSeedImageText.unreadable(origin) }];
+         }
+-        else if (origin.kind === "tool" && occurrence.answered && shownEarlier === undefined) {
+-            replacement = [{ type: "text", text: coldSeedImageText.answered(origin) }];
++        else if (occurrence.answered && shownEarlier === undefined) {
++            replacement = [{ type: "text", text: origin.kind === "tool" ? coldSeedImageText.answered(origin) : coldSeedImageText.userAnswered }];
+         }
+         else if (!replayed.has(hash) && shownEarlier === undefined) {
+             replacement = [{ type: "text", text: coldSeedImageText.capped(origin) }];
+@@ -159,4 +162,4 @@
+     }
+     return rewritten;
+ }
+-//# sourceMappingURL=cold-seed-images.js.map
+
++//# sourceMappingURL=cold-seed-images.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/errors.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/errors.js
+@@ -1,4 +1,5 @@
+ import { rateLimitModelFamily } from "../../../credential-pool/model-scope.js";
++import { isClaudeSdkRefusal } from "./refusal.js";
+ const SDK_ERROR_CLASSIFICATIONS = {
+     authentication_failed: { kind: "auth_error", retryable: true },
+     oauth_org_not_allowed: { kind: "org_not_allowed", retryable: true },
+@@ -76,6 +77,8 @@
+ }
+ /** Classifies Anthropic Subscription error codes and HTTP-shaped fallback text in one place. */
+ export function classifySdkError(error) {
++    if (isClaudeSdkRefusal(error))
++        return OTHER_ERROR;
+     const classification = classifyErrorKind(error);
+     if (classification.kind !== "rate_limit")
+         return classification;
+@@ -130,4 +133,4 @@
+     }
+     return OTHER_ERROR;
+ }
+-//# sourceMappingURL=errors.js.map
+
++//# sourceMappingURL=errors.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/refusal.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/refusal.js
+@@ -26,6 +26,13 @@
+     return details ? new ClaudeSdkRefusalError(details.content, details.category) : undefined;
+ }
+ export function isClaudeSdkRefusal(error) {
+-    return error instanceof ClaudeSdkRefusalError;
++    return getClaudeSdkRefusal(error) !== undefined;
+ }
+-//# sourceMappingURL=refusal.js.map
+
++export function getClaudeSdkRefusal(error) {
++    if (error instanceof ClaudeSdkRefusalError)
++        return error;
++    if (error !== null && typeof error === "object" && "original" in error)
++        return getClaudeSdkRefusal(error.original);
++    return undefined;
++}
++//# sourceMappingURL=refusal.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/stream.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/stream.js
+@@ -9,7 +9,7 @@
+ import { buildDeferredPromptStream, buildPromptBlocks } from "./prompt-bridge.js";
+ import { pinOneShotPromptCacheTtl } from "./prompt-cache-ttl.js";
+ import { dedupeUltraworkBlocks } from "./prompt-directive-dedupe.js";
+-import { refusalError } from "./refusal.js";
++import { getClaudeSdkRefusal, refusalError } from "./refusal.js";
+ import { getSdkBoundary, loadClaudeAgentSdk } from "./sdk-boundary.js";
+ import { emitContinuityObservation } from "./session-observability.js";
+ import { forgetBinding } from "./session-reattach.js";
+@@ -74,7 +74,7 @@
+             claudeCodeRun = resolveClaudeCodeRun(defaultExecutableDeps());
+             const executable = claudeCodeRun.executable;
+             let oneShotCacheTtl;
+-            const buildOptions = (authLane) => {
++            const buildOptions = async (authLane) => {
+                 const queryOptions = buildAnthropicSubscriptionQueryOptions({
+                     model,
+                     context,
+@@ -97,7 +97,8 @@
+                 if (!useResidentSession) {
+                     oneShotCacheTtl = pinOneShotPromptCacheTtl(queryOptions, authLane ?? providerSettings.tokenInjection ?? "ambient", { ...process.env, ...options?.env });
+                 }
+-                return queryOptions;
++                const replacement = await options?.onPayload?.(queryOptions, model);
++                return replacement === undefined ? queryOptions : replacement;
+             };
+             const recordContinuity = (observation) => {
+                 // Not a failure: carry the observation as details only, with no synthesized error.
+@@ -252,6 +253,9 @@
+             if (nativeCompactionStopped && options?.sessionId)
+                 forgetBinding(options.sessionId);
+             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
++            const refusal = getClaudeSdkRefusal(error);
++            if (refusal)
++                output.stopDetails = { type: "refusal", explanation: refusal.message };
+             // A failed result still bills its tokens; managed and resident lanes
+             // throw before the result reaches this loop, so account for it here.
+             const billed = sdkResultFailureUsage(error);
+@@ -269,4 +273,4 @@
+     })();
+     return stream;
+ }
+-//# sourceMappingURL=stream.js.map
+
++//# sourceMappingURL=stream.js.map
+--- a/@code-yeongyu/senpi/dist/core/model-runtime.js
++++ b/@code-yeongyu/senpi/dist/core/model-runtime.js
+@@ -76,6 +76,7 @@
+         onPayload: async (payload, providerModel) => await onPayload(payload, providerModel, {
+             model,
+             headers: options.headers ?? {},
++            streamKind: options.streamKind,
+         }),
+     };
+ }
+@@ -1160,4 +1161,4 @@
+         return model && !isVirtualModel(model) ? model : undefined;
+     }
+ }
+-//# sourceMappingURL=model-runtime.js.map
+
++//# sourceMappingURL=model-runtime.js.map
+--- a/@earendil-works/pi-agent-core/dist/agent.d.ts
++++ b/@earendil-works/pi-agent-core/dist/agent.d.ts
+@@ -188,6 +188,9 @@
+      * the continuation input, while timeout overrides still apply to its first provider request.
+      */
+     continueWithQueuedMessages(options?: AgentContinuationOptions): Promise<void>;
++    continueQueuedInput(clientInputId: string, options?: AgentContinuationOptions & {
++        onStart?: () => void;
++    }): Promise<"busy" | "not_head" | "resumed">;
+     /**
+      * Continue from the current transcript. The last message must be a user or tool-result message.
+      * Queue deferral and timeout overrides apply only to the first provider request; later requests in
+@@ -236,4 +239,4 @@
+      */
+     emitExternalEvent(event: AgentEvent, runSignal?: AbortSignal): Promise<void>;
+ }
+-//# sourceMappingURL=agent.d.ts.map
+
++//# sourceMappingURL=agent.d.ts.map
+--- a/@earendil-works/pi-agent-core/dist/agent.js
++++ b/@earendil-works/pi-agent-core/dist/agent.js
+@@ -297,6 +297,21 @@
+      * Queue-first recovery takes precedence over `deferQueuedMessages`: the selected queued message is
+      * the continuation input, while timeout overrides still apply to its first provider request.
+      */
++    async continueQueuedInput(clientInputId, options = {}) {
++        if (this.activeRun)
++            return "busy";
++        const steering = this.steeringQueue.hasItems();
++        const queue = steering ? this.steeringQueue : this.followUpQueue;
++        if (queue.messages[0]?.clientInputId !== clientInputId)
++            return "not_head";
++        options.onStart?.();
++        await this.runQueuedMessages(steering ? "steering" : "followUp", {
++            skipInitialSteeringPoll: steering,
++            initialRequestTimeoutMs: options.timeoutMs,
++            initialRequestStreamStartTimeoutMs: options.streamStartTimeoutMs,
++        });
++        return "resumed";
++    }
+     async continueWithQueuedMessages(options = {}) {
+         if (this.activeRun) {
+             throw new Error("Agent is already processing. Wait for completion before continuing.");
+@@ -672,4 +687,4 @@
+         await this.processEvents(event);
+     }
+ }
+-//# sourceMappingURL=agent.js.map
+
++//# sourceMappingURL=agent.js.map
+--- a/@earendil-works/pi-ai/dist/types.d.ts
++++ b/@earendil-works/pi-ai/dist/types.d.ts
+@@ -85,6 +85,7 @@
+ export type ProviderRequestMetadata = {
+     model: Model<Api>;
+     headers: ProviderHeaders;
++    streamKind?: "main" | "auxiliary";
+ };
+ export type FetchFunction = typeof globalThis.fetch;
+ export interface ProviderResponse {
+@@ -510,6 +511,8 @@
+     timestamp: number;
+ }
+ export interface UserMessage {
++    /** Gateway input identity preserved through expansion and queue consumption. */
++    clientInputId?: string;
+     role: "user";
+     content: string | (TextContent | ImageContent)[];
+     timestamp: number;
+@@ -1242,4 +1245,4 @@
+ export type ModelType = keyof ModelTypeMap;
+ /** Anything a provider can list. Narrow with `isModelType()`. */
+ export type AnyModel = ModelTypeMap[ModelType];
+-//# sourceMappingURL=types.d.ts.map
+
++//# sourceMappingURL=types.d.ts.map
+--- a/omo-ai/bin/lib/package-paths.js
++++ b/omo-ai/bin/lib/package-paths.js
+@@ -113,7 +113,8 @@
+   // launcher change.
+   const bundlePath = join(distDir, "bundle", "cli.js")
+   const unbundledPath = join(distDir, "cli.js")
+-  const cliPath = existsSync(bundlePath) ? bundlePath : unbundledPath
++  // Gateway package ports live in the unbundled graph, including relative RPC workers.
++  const cliPath = unbundledPath
+   if (!existsSync(cliPath)) {
+     throw new Error(`senpi CLI is missing at ${cliPath}; reinstall with: ${updateTarget().command}`)
+   }
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/tps.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/tps.js
+@@ -16,6 +16,8 @@
+     let lastDeltaMs = null;
+     let generationMs = 0;
+     let streamedOutput = 0;
++    let turnId = null;
++    let completedMessages = [];
+     const finishActiveAssistantTiming = () => {
+         if (activeAssistantStartMs === null)
+             return;
+@@ -34,7 +36,11 @@
+         lastDeltaMs = null;
+         thinkingStreamed = false;
+     };
+-    pi.on("agent_start", () => {
++    pi.on("agent_start", (_event, ctx) => {
++        turnId = ctx.mode === "rpc" ? crypto.randomUUID() : null;
++        completedMessages = [];
++        if (turnId !== null)
++            pi.rpc.emit("zgw.turn_started", { version: 1, turnId });
+         activeAssistantStartMs = null;
+         assistantElapsedMs = 0;
+         generationMs = 0;
+@@ -69,6 +75,7 @@
+         // counted in usage.output may be hidden or only summarised after it finished, so it was generated
+         // before the first delta. Such a message (usage.reasoning, or a thinking block whose text never
+         // streamed: Bedrock and omitted display report no reasoning count) is timed from its start.
++        completedMessages.push(event.message);
+         const output = event.message.usage?.output ?? 0;
+         const windowStart = reasonedBeforeFirstDelta(event.message, thinkingStreamed) ? messageStartMs : firstDeltaMs;
+         const counted = event.message.stopReason !== "aborted" && event.message.stopReason !== "error" && output > 0;
+@@ -83,6 +90,43 @@
+         const elapsedMs = assistantElapsedMs;
+         const measuredGenerationMs = generationMs;
+         const measuredOutput = streamedOutput;
++        // Structured RPC metadata stays out of messages and extension_ui_request notifications.
++        const completedTurnId = turnId;
++        turnId = null;
++        const messages = completedMessages;
++        completedMessages = [];
++        const finalMessage = messages.at(-1);
++        const lastAssistant = event.messages.findLast(isAssistantMessage);
++        if (ctx.mode === "rpc" && completedTurnId !== null && !event.aborted && !event.willRetry && !event.abortSource && !ctx.signal?.aborted
++            && finalMessage && (finalMessage.stopReason === "stop" || finalMessage.stopReason === "length")
++            && Number.isInteger(finalMessage.timestamp) && finalMessage.timestamp > 0
++            && lastAssistant?.timestamp === finalMessage.timestamp
++            && !messages.some((message) => message.stopReason === "error" || message.stopReason === "aborted")) {
++            const stats = {};
++            const hasOutput = messages.some((message) => Number.isFinite(message.usage?.output) && message.usage.output > 0);
++            if (hasOutput) {
++                if (Number.isFinite(elapsedMs) && elapsedMs > 0)
++                    stats.modelDurationMs = elapsedMs;
++                const rate = measuredOutput / (measuredGenerationMs / 1000);
++                if (measuredGenerationMs >= MIN_GENERATION_MS && Number.isFinite(rate) && rate > 0)
++                    stats.tokensPerSecond = rate;
++                // Unknown usage must not look like a measured zero-percent cache hit.
++                if (messages.every((message) => [message.usage?.input, message.usage?.cacheRead, message.usage?.cacheWrite]
++                    .every((value) => Number.isFinite(value) && value >= 0))) {
++                    let promptTokens = 0;
++                    let cacheRead = 0;
++                    for (const message of messages) {
++                        promptTokens += message.usage.input + message.usage.cacheRead + message.usage.cacheWrite;
++                        cacheRead += message.usage.cacheRead;
++                    }
++                    const hit = cacheRead / promptTokens * 100;
++                    if (Number.isFinite(promptTokens) && Number.isFinite(cacheRead) && Number.isFinite(hit) && hit >= 0 && hit <= 100)
++                        stats.cacheHitPercent = hit;
++                }
++            }
++            if (Object.keys(stats).length > 0)
++                pi.rpc.emit("zgw.turn_stats", { version: 1, turnId: completedTurnId, finalMessageTimestamp: finalMessage.timestamp, finalMessageIndex: messages.length, stats });
++        }
+         activeAssistantStartMs = null;
+         assistantElapsedMs = 0;
+         generationMs = 0;
+@@ -121,4 +165,4 @@
+         ctx.ui.notify(`${rate}${stats}`, "info");
+     });
+ }
+-//# sourceMappingURL=tps.js.map
+
++//# sourceMappingURL=tps.js.map