@rine-kit/agent-core 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { createChatModel, isRetryable, LlmError, toLlmError } from './llm.js';
 export type { ChatModel, LlmErrorKind, OpenAiCompatibleOptions } from './llm.js';
 export { AgentTurnService, MAX_TOOL_ROUNDS, memoryBlock } from './turn.js';
-export type { AgentTurns, AgentTurnServiceOptions, PromptMessage, TurnInput } from './turn.js';
+export type { AgentTurns, AgentTurnServiceOptions, PromptMessage, ToolRecord, TurnInput, TurnReply, } from './turn.js';
 export { toToolSet } from './tool-set.js';
 export type { LanguageModel } from 'ai';

package/dist/turn.d.ts

@@ -20,6 +20,19 @@ export interface TurnInput<Ctx> {
      * that has no clear question (or does not want memory) just leaves it out.
      */
     query?: string;
+    /** Answer from what is already in the prompt: no tool is offered (a rewrite pass after a tool result). */
+    noTools?: boolean;
+}
+/** One tool call of a turn, with what it returned: for a host that checks the answer against the results. */
+export interface ToolRecord {
+    name: string;
+    input: unknown;
+    output: unknown;
+}
+/** An answer and the tool calls made on the way to it. */
+export interface TurnReply {
+    text: string;
+    calls: ToolRecord[];
 }
 /** The lines a plugin recalled, as a block of the system prompt that cannot pass for instructions. */
 export declare function memoryBlock(lines: string[]): string;
@@ -32,9 +45,12 @@ export interface AgentTurns<Ctx> {
     /** Prompt fragments of the loaded plugins; the host puts them into its system prompt. */
     readonly instructions: string[];
     /** The finished answer of the last round (tool rounds before it are not part of the text). */
-    reply(input: TurnInput<Ctx>): Promise<{
-        text: string;
-    }>;
+    reply(input: TurnInput<Ctx>): Promise<TurnReply>;
+    /**
+     * The same answer, handed over while it is written: `onText` gets the whole text of the round being written so
+     * far (it starts over when a new round begins after a tool call). Resolves with the finished answer.
+     */
+    replyStream(input: TurnInput<Ctx>, onText: (soFar: string) => void): Promise<TurnReply>;
     /** The words of every round as they arrive; tool calls run between the rounds. */
     speech(input: TurnInput<Ctx>): AsyncGenerator<string, void, void>;
 }
@@ -59,9 +75,8 @@ export declare class AgentTurnService<Ctx> implements AgentTurns<Ctx> {
     /** What the plugins remember that bears on the question, as a prompt block (empty when nothing). */
     private recalled;
     private agent;
-    reply(input: TurnInput<Ctx>): Promise<{
-        text: string;
-    }>;
+    reply(input: TurnInput<Ctx>): Promise<TurnReply>;
+    replyStream(input: TurnInput<Ctx>, onText: (soFar: string) => void): Promise<TurnReply>;
     /**
      * Tells the plugins' observe hooks about a finished turn. Fire and forget: learning must never delay
      * the answer, and a cancelled turn teaches nothing.

package/dist/turn.js

@@ -57,7 +57,7 @@ export class AgentTurnService {
         ]
             .filter(Boolean)
             .join('\n\n');
-        const tools = this.plugins?.toolCount ? toToolSet(this.plugins, input.ctx) : undefined;
+        const tools = this.plugins?.toolCount && !input.noTools ? toToolSet(this.plugins, input.ctx) : undefined;
         const agent = new ToolLoopAgent({
             model: this.options.model,
             instructions: system || undefined,
@@ -85,12 +85,54 @@ export class AgentTurnService {
                 throw new LlmError('empty', `the model returned nothing (${result.finishReason})`);
             }
             this.observe(input, text);
-            return { text };
+            return { text, calls: toolRecords(result.steps) };
         }
         catch (err) {
             throw toLlmError(err, input.signal);
         }
     }
+    async replyStream(input, onText) {
+        const { agent, messages } = await this.agent(input);
+        let produced = false;
+        let round = '';
+        try {
+            const result = await agent.stream({ messages, abortSignal: input.signal });
+            for await (const part of result.fullStream) {
+                if (part.type === 'start-step') {
+                    round = '';
+                }
+                else if (part.type === 'text-delta') {
+                    if (!part.text)
+                        continue;
+                    produced = true;
+                    round += part.text;
+                    onText(round);
+                }
+                else if (part.type === 'tool-call') {
+                    produced = true;
+                }
+                else if (part.type === 'error') {
+                    throw part.error;
+                }
+                else if (part.type === 'abort') {
+                    throw new LlmError('aborted', 'request was cancelled');
+                }
+            }
+            const text = (await result.text).trim();
+            if (!text)
+                throw new LlmError('empty', 'the model returned nothing');
+            this.observe(input, text);
+            return { text, calls: toolRecords(await result.steps) };
+        }
+        catch (err) {
+            // A provider that just closes the stream after some words has said what it had.
+            if (InvalidResponseDataError.isInstance(err) && produced && !input.signal.aborted && round.trim()) {
+                this.observe(input, round.trim());
+                return { text: round.trim(), calls: [] };
+            }
+            throw toLlmError(err, input.signal);
+        }
+    }
     /**
      * Tells the plugins' observe hooks about a finished turn. Fire and forget: learning must never delay
      * the answer, and a cancelled turn teaches nothing.
@@ -143,3 +185,17 @@ export class AgentTurnService {
             this.observe(input, said.trim());
     }
 }
+function toolRecords(steps) {
+    return steps.flatMap((step) => step.toolResults.map((r) => ({ name: r.toolName, input: r.input, output: parsed(r.output) })));
+}
+/** Tool results reach the model as JSON text (tool-set.ts); a host checking them wants the value. */
+function parsed(output) {
+    if (typeof output !== 'string')
+        return output;
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        return output;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rine-kit/agent-core",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "The reasoning loop of an AI participant: chat model over an OpenAI-compatible endpoint, plugin tools, one turn service for text and voice. No dependency on RINE's API, LiveKit or desktop.",
   "exports": {
@@ -13,7 +13,7 @@
   "dependencies": {
     "@ai-sdk/openai-compatible": "3.0.67",
     "ai": "7.0.137",
-    "@rine-kit/plugin-sdk": "0.1.1"
+    "@rine-kit/plugin-sdk": "0.1.3"
   },
   "devDependencies": {
     "@types/node": "^26.6.5",