agent-afk 5.322.15 → 5.322.17

package/dist/agent/providers/index.d.ts

@@ -12,6 +12,7 @@ export declare function resolveProvider(model: string | undefined, hints?: Provi
     customTools?: import('../tools/custom-tool.js').CustomToolDef[];
     canUseTool?: import('../types/sdk-types.js').CanUseTool;
     executors?: import('../session/session-executors.js').ProviderExecutorOpts;
+    mcpManager?: import('../mcp/index.js').McpManager;
 }): ModelProvider;
 export { anthropicDirectProvider };
 export { AnthropicDirectProvider } from './anthropic-direct/index.js';

package/dist/agent/providers/openai-compatible/query/wind-down-final.d.ts

@@ -0,0 +1,3 @@
+export declare const WIND_DOWN_NO_ANSWER_PLACEHOLDER: string;
+export declare function stripToolCallMarkup(text: string): string;
+export declare function windDownFinalText(roundText: string): string;

package/dist/agent/session/agent-session.d.ts

@@ -11,6 +11,8 @@ export declare class AgentSession implements IAgentSession {
     private readonly ownedTraceWriter;
     private config;
     private stopWiring;
+    private ownedMcpManager;
+    private mcpInitPromise;
     private readonly planExit;
     private currentState;
     private providerQuery;

package/dist/agent/session/agent-session.lifecycle.d.ts

@@ -0,0 +1,58 @@
+import { TurnStreamRunner } from './turn-stream-runner.js';
+import type { AgentConfig } from '../types.js';
+import type { AccountingAccumulator } from './accounting-accumulator.js';
+import type { SessionShutdown } from './session-shutdown.js';
+import type { SessionStateManager } from './session-state.js';
+import type { HookRegistry } from '../hooks.js';
+import type { ProviderQuery, ProviderEvent } from '../provider.js';
+import type { QueryInputStream } from './input-iterable.js';
+export interface SessionRunnerSlots {
+    getConfig: () => AgentConfig;
+    getAbortController: () => AbortController;
+    getProviderIterator: () => AsyncIterator<ProviderEvent>;
+    stateManager: SessionStateManager;
+    accounting: AccountingAccumulator;
+    ledger: import('./ledger-lifecycle.js').LedgerLifecycle;
+    outputBroadcast: import('./output-broadcast.js').OutputBroadcast;
+    conversationHistory: import('../types.js').Message[];
+    getInitPromise: () => Promise<void> | null;
+    getSessionId: () => string | undefined;
+    getState: () => import('../types.js').SessionState;
+    setState: (s: import('../types.js').SessionState) => void;
+    getLastResponseMetadata: () => import('../types.js').ResponseMetadata | null;
+    setLastResponseMetadata: (m: import('../types.js').ResponseMetadata | null) => void;
+    getPendingFrameworkContext: () => string[];
+    setPendingFrameworkContext: (v: string[]) => void;
+    getInboundMessageCount: () => number;
+    incInboundMessageCount: () => number;
+    getTurnCount: () => number;
+    incTurnCount: () => void;
+    getProviderQuery: () => ProviderQuery;
+    getStopWiring: () => import('../types/session-types.js').StopWiring | undefined;
+    observeProviderEvent: (e: ProviderEvent) => void;
+}
+export declare function buildSessionRunner(slots: SessionRunnerSlots): TurnStreamRunner;
+export interface LifecycleWriteSlots {
+    setStateManager: (v: SessionStateManager) => void;
+    setInputStream: (v: import('./input-iterable.js').QueryInputStream) => void;
+    setProviderQuery: (v: ProviderQuery) => void;
+    setProviderIterator: (v: AsyncIterator<ProviderEvent>) => void;
+}
+export declare function applyLifecycle(config: AgentConfig, slots: LifecycleWriteSlots): SessionStateManager;
+export interface BuildInitPromiseOptions {
+    mcpInitPromise: Promise<void>;
+    getConfig: () => AgentConfig;
+    setProviderQuery: (q: ProviderQuery) => void;
+    setProviderIterator: (i: AsyncIterator<ProviderEvent>) => void;
+    getProviderIterator: () => AsyncIterator<ProviderEvent>;
+    getInputStream: () => QueryInputStream;
+    isClosed: () => boolean;
+    abortSignal: AbortSignal;
+    accounting: AccountingAccumulator;
+    shutdown: SessionShutdown;
+    hookRegistry: HookRegistry | undefined;
+    queueFrameworkContext: (text: string) => void;
+    getRunner: () => TurnStreamRunner;
+    stateManager: SessionStateManager;
+}
+export declare function buildSessionInitPromise(opts: BuildInitPromiseOptions): Promise<void>;

package/dist/agent/session/agent-session.mcp.d.ts

@@ -0,0 +1,9 @@
+import { McpManager } from '../mcp/manager.js';
+import type { AgentConfig } from '../types.js';
+export interface SdkMcpResult {
+    ownedManager: McpManager | undefined;
+    resolvedManager: McpManager | undefined;
+}
+export declare function disconnectOwnedManager(manager: McpManager | undefined): Promise<void>;
+export declare function startMcpInit(config: AgentConfig, setOwnedManager: (m: McpManager) => void, patchConfig: (m: McpManager) => void, isClosed: () => boolean): Promise<void>;
+export declare function initSdkOwnedMcpManager(config: AgentConfig): Promise<SdkMcpResult>;

package/dist/agent/session/provider-lifecycle.d.ts

@@ -3,7 +3,7 @@ import { QueryInputStream } from './input-iterable.js';
 import type { AccountingAccumulator } from './accounting-accumulator.js';
 import type { SessionShutdown } from './session-shutdown.js';
 import type { AgentConfig } from '../types.js';
-import type { ProviderQuery, ProviderEvent } from '../provider.js';
+import type { ProviderQuery, ProviderEvent, ProviderUserTurn } from '../provider.js';
 import type { HookRegistry } from '../hooks.js';
 import type { TransformDeps } from './stream-consumer.js';
 export interface ProviderLifecycleResult {
@@ -12,6 +12,11 @@ export interface ProviderLifecycleResult {
     providerQuery: ProviderQuery;
     providerIterator: AsyncIterator<ProviderEvent>;
 }
+export interface ProviderQueryResult {
+    providerQuery: ProviderQuery;
+    providerIterator: AsyncIterator<ProviderEvent>;
+}
+export declare function rebuildProviderQuery(config: AgentConfig, promptIterable: AsyncIterable<ProviderUserTurn>): ProviderQueryResult;
 export declare function buildProviderLifecycle(config: AgentConfig): ProviderLifecycleResult;
 export declare class ProviderInitializer {
     private readonly config;

package/dist/agent/tools/readonly-git-surface.d.ts

@@ -5,4 +5,6 @@ export declare function isReadOnlyGitToolEnabled(): boolean;
 export declare function swapBashForGitRead(tools: readonly string[]): string[];
 export declare function applyReadOnlyGitPermissions(permissions: ToolPermissionConfig | undefined, readOnlyBash: boolean | undefined): ToolPermissionConfig | undefined;
 export declare const READONLY_BASH_DISABLED_REASON: string;
+export declare function readOnlyBashDenialOverride(toolName: string, readOnlyBash: boolean): string | undefined;
+export declare function withGitReadSubstitution(body: string): string;
 export declare function readOnlyGitSchemas(): AnthropicToolDef[];

package/dist/agent/trace/otlp-export.d.ts

@@ -0,0 +1,56 @@
+import type { TraceEvent } from './types.js';
+type AnyValue = {
+    stringValue: string;
+} | {
+    intValue: string;
+} | {
+    boolValue: boolean;
+} | {
+    doubleValue: number;
+};
+interface KeyValue {
+    key: string;
+    value: AnyValue;
+}
+interface SpanEvent {
+    timeUnixNano: string;
+    name: string;
+    attributes?: KeyValue[];
+}
+interface SpanStatus {
+    code: 0 | 1 | 2;
+    message?: string;
+}
+export interface OtlpSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind: number;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes: KeyValue[];
+    events?: SpanEvent[];
+    status: SpanStatus;
+}
+export interface OtlpResourceSpans {
+    resource: {
+        attributes: KeyValue[];
+    };
+    scopeSpans: Array<{
+        scope: {
+            name: string;
+            version: string;
+        };
+        spans: OtlpSpan[];
+    }>;
+}
+export interface OtlpExportRequest {
+    resourceSpans: OtlpResourceSpans[];
+}
+export interface TraceToOtlpOptions {
+    sessionId: string;
+    malformed?: number;
+}
+export declare function traceToOtlp(events: readonly TraceEvent[], opts: TraceToOtlpOptions): OtlpExportRequest;
+export {};