@jini-ai/agent-runtime 0.3.10 → 0.4.0

package/dist/agent-protocol/core/json-line-stream.d.ts

@@ -16,10 +16,19 @@ export interface JsonLineAccumulatorState {
     pendingJson: string;
     pendingJsonLineCount: number;
 }
-export declare function emitJsonLine(candidate: string, onMessage: (message: unknown, rawLine: string) => void): boolean;
-export declare function continuePendingJsonLine(state: JsonLineAccumulatorState, trimmed: string, onMessage: (message: unknown, rawLine: string) => void): void;
+export declare function emitJsonLine(candidate: string, onMessage: (requiredArgs: {
+    message: unknown;
+    rawLine: string;
+}) => void): boolean;
+export declare function continuePendingJsonLine(state: JsonLineAccumulatorState, trimmed: string, onMessage: (requiredArgs: {
+    message: unknown;
+    rawLine: string;
+}) => void): void;
 export declare function tryStartPendingJsonLine(state: JsonLineAccumulatorState, trimmed: string): void;
-export declare function handleJsonLine(state: JsonLineAccumulatorState, line: string, onMessage: (message: unknown, rawLine: string) => void): void;
+export declare function handleJsonLine(state: JsonLineAccumulatorState, line: string, onMessage: (requiredArgs: {
+    message: unknown;
+    rawLine: string;
+}) => void): void;
 /**
  * Creates a streaming JSON-line parser over a raw byte/string stream.
  * Buffers incoming chunks, splits on newline boundaries, and attempts
@@ -30,13 +39,20 @@ export declare function handleJsonLine(state: JsonLineAccumulatorState, line: st
  * Used as the shared ACP transport: both the acp/ and pi-rpc/ adapters call
  * this to decode JSON-RPC frames from a subprocess's stdout.
  *
- * @param onMessage - Called for each successfully parsed JSON value along with
- *   the raw reassembled line string as a second argument.
- * @returns An object with `feed(chunk)` for incremental input and `flush()` to
+ * @param requiredArgs.onMessage - Called with `{ message, rawLine }` for each
+ *   successfully parsed JSON value and its raw reassembled line string.
+ * @returns An object with `feed({ chunk })` for incremental input and `flush()` to
  *   drain any residual buffered content at stream end.
  */
-export declare function createJsonLineStream(onMessage: (message: unknown, rawLine: string) => void): {
-    feed(chunk: string): void;
+export declare function createJsonLineStream({ onMessage }: {
+    onMessage: (requiredArgs: {
+        message: unknown;
+        rawLine: string;
+    }) => void;
+}): {
+    feed({ chunk }: {
+        chunk: string;
+    }): void;
     flush(): void;
 };
 export type JsonObjectScanFrame = {

package/dist/agent-protocol/core/json-line-stream.js

@@ -22,7 +22,7 @@ function resetPendingJson(state) {
 }
 export function emitJsonLine(candidate, onMessage) {
     try {
-        onMessage(JSON.parse(candidate), candidate);
+        onMessage({ message: JSON.parse(candidate), rawLine: candidate });
         return true;
     }
     catch {
@@ -81,16 +81,16 @@ export function handleJsonLine(state, line, onMessage) {
  * Used as the shared ACP transport: both the acp/ and pi-rpc/ adapters call
  * this to decode JSON-RPC frames from a subprocess's stdout.
  *
- * @param onMessage - Called for each successfully parsed JSON value along with
- *   the raw reassembled line string as a second argument.
- * @returns An object with `feed(chunk)` for incremental input and `flush()` to
+ * @param requiredArgs.onMessage - Called with `{ message, rawLine }` for each
+ *   successfully parsed JSON value and its raw reassembled line string.
+ * @returns An object with `feed({ chunk })` for incremental input and `flush()` to
  *   drain any residual buffered content at stream end.
  */
-export function createJsonLineStream(onMessage) {
+export function createJsonLineStream({ onMessage }) {
     let buffer = '';
     const state = { pendingJson: '', pendingJsonLineCount: 0 };
     return {
-        feed(chunk) {
+        feed({ chunk }) {
             buffer += chunk;
             const lines = buffer.split('\n');
             buffer = lines.pop() || '';
@@ -114,7 +114,7 @@ export function createJsonLineStream(onMessage) {
             // a defensive `if (pendingJson && emit(pendingJson)) { pendingJson =
             // '' }` here that was provably dead code; removed per this package's
             // coverage-driven dead-branch discipline rather than left uncovered or
-            // suppressed. See source-map.md.
+            // suppressed. See archived provenance ledger.
             // Ignore trailing non-JSON log lines on stdout.
         },
     };
@@ -136,7 +136,7 @@ export function afterValue(state) {
 // guard was provably dead (verified by a 2M-trial adversarial fuzz,
 // including deliberately malformed bracket sequences, finding zero
 // mismatches) and is removed here per this package's coverage-driven
-// dead-branch discipline. See source-map.md.
+// dead-branch discipline. See archived provenance ledger.
 function closeFrame(state) {
     state.stack.pop();
     afterValue(state);

package/dist/agent-protocol/pi-rpc/events.d.ts

@@ -43,5 +43,9 @@ export declare function handleAutoRetryEnd(raw: JsonRecord, send: SendAgentEvent
  * @param ctx  - Per-run context: start timestamp and first-token sentinel.
  * @returns `'agent_end'` on run completion, `null` otherwise.
  */
-export declare function mapPiRpcEvent(raw: JsonRecord, send: SendAgentEvent, ctx: PiRpcContext): 'agent_end' | null;
+export declare function mapPiRpcEvent({ raw, send, ctx }: {
+    raw: JsonRecord;
+    send: SendAgentEvent;
+    ctx: PiRpcContext;
+}): 'agent_end' | null;
 //# sourceMappingURL=events.d.ts.map

package/dist/agent-protocol/pi-rpc/events.js

@@ -1,13 +1,13 @@
 import { getRecord } from './internal.js';
 export function handleAgentStart(_raw, send) {
-    send('agent', { type: 'status', label: 'working' });
+    send({ event: 'agent', payload: { type: 'status', label: 'working' } });
     return null;
 }
 export function handleAgentEnd() {
     return 'agent_end';
 }
 export function handleTurnStart(_raw, send) {
-    send('agent', { type: 'status', label: 'thinking' });
+    send({ event: 'agent', payload: { type: 'status', label: 'thinking' } });
     return null;
 }
 /** Extracts the subset of pi's `message.usage` fields the daemon reports as token usage. */
@@ -30,12 +30,12 @@ export function emitTurnEndUsage(u, send, ctx) {
     if (Object.keys(usage).length === 0)
         return;
     const cost = getRecord(u.cost);
-    send('agent', {
-        type: 'usage',
-        usage,
-        costUsd: cost?.total ?? cost?.totalCost ?? null,
-        durationMs: Date.now() - ctx.runStartedAt,
-    });
+    send({ event: 'agent', payload: {
+            type: 'usage',
+            usage,
+            costUsd: cost?.total ?? cost?.totalCost ?? null,
+            durationMs: Date.now() - ctx.runStartedAt,
+        } });
 }
 export function emitTurnEndErrorIfPresent(message, raw, send) {
     if (message?.stopReason !== 'error')
@@ -43,7 +43,7 @@ export function emitTurnEndErrorIfPresent(message, raw, send) {
     const messageText = typeof message.errorMessage === 'string' && message.errorMessage.length > 0
         ? message.errorMessage
         : 'Pi agent error';
-    send('agent', { type: 'error', message: messageText, raw });
+    send({ event: 'agent', payload: { type: 'error', message: messageText, raw } });
 }
 export function handleTurnEnd(raw, send, ctx) {
     const message = getRecord(raw.message);
@@ -58,24 +58,24 @@ export function handleAssistantTextDelta(ev, send, ctx) {
         return;
     if (!ctx.sentFirstToken.value) {
         ctx.sentFirstToken.value = true;
-        send('agent', {
-            type: 'status',
-            label: 'streaming',
-            ttftMs: Date.now() - ctx.runStartedAt,
-        });
+        send({ event: 'agent', payload: {
+                type: 'status',
+                label: 'streaming',
+                ttftMs: Date.now() - ctx.runStartedAt,
+            } });
     }
-    send('agent', { type: 'text_delta', delta: ev.delta });
+    send({ event: 'agent', payload: { type: 'text_delta', delta: ev.delta } });
 }
 export function handleAssistantThinkingDelta(ev, send) {
     if (typeof ev.delta !== 'string')
         return;
-    send('agent', { type: 'thinking_delta', delta: ev.delta });
+    send({ event: 'agent', payload: { type: 'thinking_delta', delta: ev.delta } });
 }
 export function handleAssistantThinkingStart(_ev, send) {
-    send('agent', { type: 'thinking_start' });
+    send({ event: 'agent', payload: { type: 'thinking_start' } });
 }
 export function handleAssistantThinkingEnd(_ev, send) {
-    send('agent', { type: 'thinking_end' });
+    send({ event: 'agent', payload: { type: 'thinking_end' } });
 }
 // pi's RPC protocol emits a message_update with error delta when
 // the model returns an error (e.g. aborted, context overflow).
@@ -87,7 +87,7 @@ export function handleAssistantError(ev, send, _ctx, raw) {
         : typeof ev.delta === 'string' && ev.delta.length > 0
             ? ev.delta
             : 'Agent error';
-    send('agent', { type: 'error', message, raw });
+    send({ event: 'agent', payload: { type: 'error', message, raw } });
 }
 const ASSISTANT_MESSAGE_EVENT_HANDLERS = {
     text_delta: handleAssistantTextDelta,
@@ -112,12 +112,12 @@ export function handleMessageEnd() {
     return null;
 }
 export function handleToolExecutionStart(raw, send) {
-    send('agent', {
-        type: 'tool_use',
-        id: raw.toolCallId ?? null,
-        name: raw.toolName ?? null,
-        input: raw.args ?? null,
-    });
+    send({ event: 'agent', payload: {
+            type: 'tool_use',
+            id: raw.toolCallId ?? null,
+            name: raw.toolName ?? null,
+            input: raw.args ?? null,
+        } });
     return null;
 }
 export function handleToolExecutionEnd(raw, send) {
@@ -133,12 +133,12 @@ export function handleToolExecutionEnd(raw, send) {
         : typeof content === 'string'
             ? content
             : '';
-    send('agent', {
-        type: 'tool_result',
-        toolUseId: raw.toolCallId ?? null,
-        content: text,
-        isError: raw.isError === true,
-    });
+    send({ event: 'agent', payload: {
+            type: 'tool_result',
+            toolUseId: raw.toolCallId ?? null,
+            content: text,
+            isError: raw.isError === true,
+        } });
     return null;
 }
 // pi's RPC protocol can emit `extension_error` when an extension
@@ -149,15 +149,15 @@ export function handleExtensionError(raw, send) {
     const message = typeof raw.error === 'string' && raw.error.length > 0
         ? raw.error
         : 'Extension error';
-    send('agent', { type: 'error', message, raw });
+    send({ event: 'agent', payload: { type: 'error', message, raw } });
     return null;
 }
 export function handleCompactionStart(_raw, send) {
-    send('agent', { type: 'status', label: 'compacting' });
+    send({ event: 'agent', payload: { type: 'status', label: 'compacting' } });
     return null;
 }
 export function handleAutoRetryStart(_raw, send) {
-    send('agent', { type: 'status', label: 'retrying' });
+    send({ event: 'agent', payload: { type: 'status', label: 'retrying' } });
     return null;
 }
 export function handleAutoRetryEnd(raw, send) {
@@ -169,7 +169,7 @@ export function handleAutoRetryEnd(raw, send) {
     const message = typeof raw.finalError === 'string' && raw.finalError.length > 0
         ? raw.finalError
         : 'Auto-retry exhausted';
-    send('agent', { type: 'error', message, raw });
+    send({ event: 'agent', payload: { type: 'error', message, raw } });
     return null;
 }
 const PI_RPC_EVENT_HANDLERS = {
@@ -196,7 +196,7 @@ const PI_RPC_EVENT_HANDLERS = {
  * @param ctx  - Per-run context: start timestamp and first-token sentinel.
  * @returns `'agent_end'` on run completion, `null` otherwise.
  */
-export function mapPiRpcEvent(raw, send, ctx) {
+export function mapPiRpcEvent({ raw, send, ctx }) {
     const handler = typeof raw.type === 'string' ? PI_RPC_EVENT_HANDLERS[raw.type] : undefined;
     return handler ? handler(raw, send, ctx) : null;
 }

package/dist/agent-protocol/pi-rpc/internal.d.ts

@@ -6,7 +6,10 @@
 /** A plain JSON object — the base payload type for pi RPC messages. */
 export type JsonRecord = Record<string, unknown>;
 /** Callback signature for forwarding a typed event to the daemon's SSE layer. */
-export type SendAgentEvent = (channel: string, payload: JsonRecord) => void;
+export type SendAgentEvent = (requiredArgs: {
+    event: string;
+    payload: JsonRecord;
+}) => void;
 /** Optional token-count fields surfaced by pi's RPC protocol on turn completion. */
 export type TokenUsage = {
     input_tokens?: number;

package/dist/agent-protocol/pi-rpc/models.d.ts

@@ -17,5 +17,7 @@ export type PiModelOption = {
  * @param stdout - Raw stdout captured from `pi --list-models`, as a string or Buffer.
  * @returns Parsed model array (at least 2 entries), or `null` when nothing is found.
  */
-export declare function parsePiModels(stdout: unknown): PiModelOption[] | null;
+export declare function parsePiModels({ stdout }: {
+    stdout: unknown;
+}): PiModelOption[] | null;
 //# sourceMappingURL=models.d.ts.map

package/dist/agent-protocol/pi-rpc/models.js

@@ -12,7 +12,7 @@
  * @param stdout - Raw stdout captured from `pi --list-models`, as a string or Buffer.
  * @returns Parsed model array (at least 2 entries), or `null` when nothing is found.
  */
-export function parsePiModels(stdout) {
+export function parsePiModels({ stdout }) {
     const lines = String(stdout || '')
         .split('\n')
         .map((l) => l.trim())

package/dist/agent-protocol/pi-rpc/session.d.ts

@@ -141,5 +141,5 @@ export declare function handlePiResponseMessage({ raw, parentSessionRpcId, promp
  *                  parent session path for conversation resume.
  * @returns A `PiRpcSession` handle with `hasFatalError`, `getLastSessionPath`, and `abort`.
  */
-export declare function attachPiRpcSession({ child, prompt, cwd, model, send, imagePaths, uploadRoot, parentSession, }: PiRpcSessionOptions): PiRpcSession;
+export declare function attachPiRpcSession(requiredArgs: Pick<PiRpcSessionOptions, "child" | "prompt" | "send">, optionalArgs?: Omit<PiRpcSessionOptions, "child" | "prompt" | "send">): PiRpcSession;
 //# sourceMappingURL=session.d.ts.map

package/dist/agent-protocol/pi-rpc/session.js

@@ -247,7 +247,8 @@ export function handlePiResponseMessage({ raw, parentSessionRpcId, promptRpcId,
  *                  parent session path for conversation resume.
  * @returns A `PiRpcSession` handle with `hasFatalError`, `getLastSessionPath`, and `abort`.
  */
-export function attachPiRpcSession({ child, prompt, cwd, model, send, imagePaths, uploadRoot, parentSession, }) {
+export function attachPiRpcSession(requiredArgs, optionalArgs = {}) {
+    const { child, prompt, cwd, model, send, imagePaths, uploadRoot, parentSession, } = { ...optionalArgs, ...requiredArgs };
     const stdin = child.stdin;
     const stdout = child.stdout;
     if (stdin === null) {
@@ -281,17 +282,17 @@ export function attachPiRpcSession({ child, prompt, cwd, model, send, imagePaths
             return;
         finished = true;
         fatal = true;
-        send('error', { message, ...(code ? { code } : {}) });
+        send({ event: 'error', payload: { message, ...(code ? { code } : {}) } });
         if (!child.killed)
             child.kill('SIGTERM');
     };
     // Emit initial status with model name immediately — before pi even
     // responds — so the UI header shows the model name at session start.
-    send('agent', {
-        type: 'status',
-        label: 'initializing',
-        model: typeof model === 'string' && model ? model : null,
-    });
+    send({ event: 'agent', payload: {
+            type: 'status',
+            label: 'initializing',
+            model: typeof model === 'string' && model ? model : null,
+        } });
     // ---- Outbound: send new_session (if parentSession provided) then prompt via RPC ----
     stdin.on('error', (err) => {
         if (errorCode(err) !== 'EPIPE') {
@@ -351,33 +352,33 @@ export function attachPiRpcSession({ child, prompt, cwd, model, send, imagePaths
         }, shutdownMs);
     };
     // ---- Inbound: parse stdout events ----
-    const parser = createJsonLineStream((raw) => {
-        if (!isRecord(raw))
-            return;
-        // Once finished (agent_end or abort), stop processing — the run is
-        // over, so no more agent events should be emitted. We still drain
-        // stdout via parser.feed() so the pipe doesn't break; we just skip
-        // acting on the parsed objects.
-        if (finished)
-            return;
-        // Extension UI requests: auto-resolve to keep pi unblocked.
-        if (raw.type === 'extension_ui_request') {
-            replyExtensionUi(stdin, raw);
-            return;
-        }
-        if (raw.type === 'response') {
-            handlePiResponseMessage({ raw, parentSessionRpcId, promptRpcId, fail, sendPromptCommand });
-            return;
-        }
-        // Agent events: delegate to the pure mapper.
-        const result = mapPiRpcEvent(raw, send, { runStartedAt, sentFirstToken });
-        if (result === 'agent_end') {
-            handlePiAgentEnd();
-        }
-    });
+    const parser = createJsonLineStream({ onMessage: ({ message: raw }) => {
+            if (!isRecord(raw))
+                return;
+            // Once finished (agent_end or abort), stop processing — the run is
+            // over, so no more agent events should be emitted. We still drain
+            // stdout via parser.feed() so the pipe doesn't break; we just skip
+            // acting on the parsed objects.
+            if (finished)
+                return;
+            // Extension UI requests: auto-resolve to keep pi unblocked.
+            if (raw.type === 'extension_ui_request') {
+                replyExtensionUi(stdin, raw);
+                return;
+            }
+            if (raw.type === 'response') {
+                handlePiResponseMessage({ raw, parentSessionRpcId, promptRpcId, fail, sendPromptCommand });
+                return;
+            }
+            // Agent events: delegate to the pure mapper.
+            const result = mapPiRpcEvent({ raw: raw, send: send, ctx: { runStartedAt, sentFirstToken } });
+            if (result === 'agent_end') {
+                handlePiAgentEnd();
+            }
+        } });
     stdout.on('data', (chunk) => {
         try {
-            parser.feed(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+            parser.feed({ chunk: typeof chunk === 'string' ? chunk : chunk.toString('utf8') });
         }
         catch (err) {
             fail(`parser: ${errorMessage(err)}`);

package/dist/amr-model-cache.d.ts

@@ -26,11 +26,19 @@ type Fetchers = {
     fetchRemote: () => Promise<RuntimeModelOption[]>;
 };
 export declare class AmrModelLoadingCache {
-    private readonly refreshIntervalMs;
     private readonly states;
-    constructor(refreshIntervalMs?: number);
-    get(cacheKey: string, fetchers: Fetchers): Promise<AmrModelsResponse>;
-    warm(cacheKey: string, fetchRemote: () => Promise<RuntimeModelOption[]>): void;
+    private readonly refreshIntervalMs;
+    constructor(_requiredArgs?: Record<string, never>, { refreshIntervalMs }?: {
+        refreshIntervalMs?: number;
+    });
+    get({ cacheKey, fetchers }: {
+        cacheKey: string;
+        fetchers: Fetchers;
+    }): Promise<AmrModelsResponse>;
+    warm({ cacheKey, fetchRemote }: {
+        cacheKey: string;
+        fetchRemote: () => Promise<RuntimeModelOption[]>;
+    }): void;
     resetForTests(): void;
     private stateFor;
     private startRefresh;

package/dist/amr-model-cache.js

@@ -1,3 +1,4 @@
+import { coalesceModelLoad } from './model-loading-state.js';
 // The AMR model catalog changes rarely (new models land on the order of
 // days), and a cached remote list is returned immediately while a refresh
 // runs in the background — `get()` never blocks on the network when a
@@ -11,12 +12,12 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error ?? 'unknown error');
 }
 export class AmrModelLoadingCache {
-    refreshIntervalMs;
     states = new Map();
-    constructor(refreshIntervalMs = DEFAULT_REMOTE_REFRESH_INTERVAL_MS) {
+    refreshIntervalMs;
+    constructor(_requiredArgs = {}, { refreshIntervalMs = DEFAULT_REMOTE_REFRESH_INTERVAL_MS } = {}) {
         this.refreshIntervalMs = refreshIntervalMs;
     }
-    async get(cacheKey, fetchers) {
+    async get({ cacheKey, fetchers }) {
         const state = this.stateFor(cacheKey);
         const now = Date.now();
         if (state.remote) {
@@ -40,7 +41,7 @@ export class AmrModelLoadingCache {
             ...(state.lastRemoteError ? { remoteError: state.lastRemoteError } : {}),
         };
     }
-    warm(cacheKey, fetchRemote) {
+    warm({ cacheKey, fetchRemote }) {
         this.startRefresh(this.stateFor(cacheKey), fetchRemote);
     }
     resetForTests() {
@@ -55,24 +56,19 @@ export class AmrModelLoadingCache {
         return created;
     }
     startRefresh(state, fetchRemote) {
-        if (state.inFlight)
-            return;
-        state.inFlight = (async () => {
-            try {
-                const models = await fetchRemote();
-                if (models.length === 0) {
-                    throw new Error('AMR remote model list returned no chat models');
+        void coalesceModelLoad({ state, load: async () => {
+                try {
+                    const models = await fetchRemote();
+                    if (models.length === 0) {
+                        throw new Error('AMR remote model list returned no chat models');
+                    }
+                    state.remote = { models, fetchedAt: Date.now() };
+                    state.lastRemoteError = null;
+                }
+                catch (error) {
+                    state.lastRemoteError = errorMessage(error);
                 }
-                state.remote = { models, fetchedAt: Date.now() };
-                state.lastRemoteError = null;
-            }
-            catch (error) {
-                state.lastRemoteError = errorMessage(error);
-            }
-            finally {
-                state.inFlight = null;
-            }
-        })();
+            } });
     }
 }
 export const amrModelLoadingCache = new AmrModelLoadingCache();

package/dist/amr-profile-resolver.d.ts

@@ -15,7 +15,9 @@
  */
 export interface AmrProfileResolver {
     /** Return a scope key for the `amr` agent's remembered-live-models cache, derived from the spawn env. */
-    resolveProfile(env: NodeJS.ProcessEnv): string;
+    resolveProfile(requiredArgs: {
+        env: NodeJS.ProcessEnv;
+    }): string;
 }
 export declare const noopAmrProfileResolver: AmrProfileResolver;
 //# sourceMappingURL=amr-profile-resolver.d.ts.map

package/dist/artifact-taxonomy.d.ts

@@ -18,9 +18,13 @@
  */
 export interface ArtifactTaxonomy {
     /** Does this file path count as a user-facing artifact? (OD: html/svg/prototype/live-artifact.) */
-    isArtifact(path: string): boolean;
+    isArtifact(requiredArgs: {
+        path: string;
+    }): boolean;
     /** Optional finer buckets a host tracks for analytics; the engine treats all buckets as opaque. */
-    classify?(path: string): string | null;
+    classify?(requiredArgs: {
+        path: string;
+    }): string | null;
 }
 /** Classifies nothing as an artifact and provides no finer buckets — a safe default until a host supplies its own taxonomy. */
 export declare const noopArtifactTaxonomy: ArtifactTaxonomy;

package/dist/auth.d.ts

@@ -7,21 +7,58 @@ export type AgentAuthProbeResult = {
     exitCode?: number | null;
     signal?: string | null;
 };
-export declare function cursorAuthGuidance(hostName?: string): string;
-export declare function deepseekAuthGuidance(hostName?: string): string;
-export declare function antigravityAuthGuidance(hostName?: string): string;
+export declare function cursorAuthGuidance({}: {}, { hostName }?: {
+    hostName?: string;
+}): string;
+export declare function deepseekAuthGuidance({}: {}, { hostName }?: {
+    hostName?: string;
+}): string;
+export declare function antigravityAuthGuidance({}: {}, { hostName }?: {
+    hostName?: string;
+}): string;
 export declare function antigravityQuotaGuidance(): string;
-export declare function reasonixAuthGuidance(hostName?: string): string;
-export declare function claudeAuthGuidance(hostName?: string): string;
-export declare function geminiAuthGuidance(hostName?: string): string;
-export declare function isCursorAuthFailureText(text: string): boolean;
-export declare function isAntigravityAuthFailureText(text: string): boolean;
-export declare function isDeepSeekAuthFailureText(text: string): boolean;
-export declare function isReasonixAuthFailureText(text: string): boolean;
-export declare function isClaudeAuthFailureText(text: string): boolean;
-export declare function isGeminiAuthFailureText(text: string): boolean;
-export declare function classifyAgentAuthFailure(agentId: string, text: string, hostName?: string): AgentAuthProbeResult | null;
+export declare function reasonixAuthGuidance({}: {}, { hostName }?: {
+    hostName?: string;
+}): string;
+export declare function claudeAuthGuidance({}: {}, { hostName }?: {
+    hostName?: string;
+}): string;
+export declare function geminiAuthGuidance({}: {}, { hostName }?: {
+    hostName?: string;
+}): string;
+export declare function isCursorAuthFailureText({ text }: {
+    text: string;
+}): boolean;
+export declare function isAntigravityAuthFailureText({ text }: {
+    text: string;
+}): boolean;
+export declare function isDeepSeekAuthFailureText({ text }: {
+    text: string;
+}): boolean;
+export declare function isReasonixAuthFailureText({ text }: {
+    text: string;
+}): boolean;
+export declare function isClaudeAuthFailureText({ text }: {
+    text: string;
+}): boolean;
+export declare function isGeminiAuthFailureText({ text }: {
+    text: string;
+}): boolean;
+export declare function classifyAgentAuthFailure({ agentId, text }: {
+    agentId: string;
+    text: string;
+}, { hostName }?: {
+    hostName?: string;
+}): AgentAuthProbeResult | null;
 export type AgentServiceFailureCode = 'AGENT_AUTH_REQUIRED' | 'RATE_LIMITED' | 'UPSTREAM_UNAVAILABLE';
-export declare function classifyAgentServiceFailure(text: string): AgentServiceFailureCode | null;
-export declare function probeAgentAuthStatus(def: Pick<RuntimeAgentDef, 'id' | 'name' | 'authProbe'>, resolvedBin: string, env: RuntimeEnv, hostName?: string): Promise<AgentAuthProbeResult | null>;
+export declare function classifyAgentServiceFailure({ text }: {
+    text: string;
+}): AgentServiceFailureCode | null;
+export declare function probeAgentAuthStatus({ def, resolvedBin, env }: {
+    def: Pick<RuntimeAgentDef, 'id' | 'name' | 'authProbe'>;
+    resolvedBin: string;
+    env: RuntimeEnv;
+}, { hostName }?: {
+    hostName?: string;
+}): Promise<AgentAuthProbeResult | null>;
 //# sourceMappingURL=auth.d.ts.map