@noetic-tools/core 0.0.1 → 0.1.1

package/dist/harness/model-call.d.ts

@@ -0,0 +1,50 @@
+import type { OpenRouter } from '@openrouter/agent';
+import type { MessageQueue } from '../runtime/message-queue.js';
+import type { ItemSchemaRegistry } from '../schemas/item.js';
+import type { LLMResponse } from '../types/common.js';
+import type { AgentHarnessContract, CallModelRequest } from '../types/runtime.js';
+interface StreamIdleWatchdog {
+    /** Bump the deadline because a stream event just arrived. */
+    reset: () => void;
+    /** Clear the pending timer. Safe to call multiple times. */
+    stop: () => void;
+}
+/** @internal Create a watchdog that aborts `controller` when no
+ *  {@link StreamIdleWatchdog.reset reset} is called within `timeoutMs`. When
+ *  `timeoutMs <= 0`, returns an inert no-op so callers can always call `.reset()`
+ *  / `.stop()` without a branch. Starts armed: the caller is responsible for
+ *  `.stop()` in a `finally`. `onTimeout` runs before the abort so observers can
+ *  emit a framework event with the original cause. Exported only for unit tests. */
+export declare function createStreamIdleWatchdog(timeoutMs: number, controller: AbortController, onTimeout?: () => void): StreamIdleWatchdog;
+/** @internal Context carries the session queue reference so callModel can
+ *  inject between-rounds messages into the current tool-round loop. */
+export interface SessionCtxExtension {
+    _sessionQueue?: MessageQueue;
+    _sessionBetweenRounds?: boolean;
+    _sessionRunnerAgentName?: string;
+}
+interface AgentHarnessModelCallerOpts {
+    agentName: string;
+    itemSchemas: ItemSchemaRegistry;
+    client?: OpenRouter;
+    callModelOverride?: (request: CallModelRequest) => Promise<LLMResponse>;
+    streamIdleTimeoutMs: number;
+    harness: AgentHarnessContract;
+}
+export declare class AgentHarnessModelCaller {
+    private readonly opts;
+    constructor(opts: AgentHarnessModelCallerOpts);
+    private callOverriddenModel;
+    private requireModelClient;
+    callModel(request: CallModelRequest): Promise<LLMResponse>;
+    private injectBetweenRoundMessages;
+    private handleModelRecovery;
+    private handleEmptyOutputRecovery;
+    private executeToolRound;
+    private executeFunctionCall;
+    private recordMalformedToolCall;
+    private handleToolRoundLimit;
+    /** @internal Drain only messages tagged `between-rounds` from the queue. */
+    private drainBetweenRoundsMessages;
+}
+export {};