indusagi 0.1.1

package/dist/agent/agent.js

@@ -0,0 +1,347 @@
+/**
+ * Agent class that uses the agent-loop directly.
+ * No transport abstraction - calls streamSimple via the loop.
+ */
+import { getModel, streamSimple, } from "../ai/index.js";
+import { agentLoop, agentLoopContinue } from "./agent-loop.js";
+/**
+ * Default convertToLlm: Keep only LLM-compatible messages, convert attachments.
+ */
+function defaultConvertToLlm(messages) {
+    return messages.filter((m) => m.role === "user" || m.role === "assistant" || m.role === "toolResult");
+}
+export class Agent {
+    constructor(opts = {}) {
+        this._state = {
+            systemPrompt: "",
+            model: getModel("google", "gemini-2.5-flash-lite-preview-06-17"),
+            thinkingLevel: "off",
+            tools: [],
+            messages: [],
+            isStreaming: false,
+            streamMessage: null,
+            pendingToolCalls: new Set(),
+            error: undefined,
+        };
+        this.listeners = new Set();
+        this.steeringQueue = [];
+        this.followUpQueue = [];
+        this._state = { ...this._state, ...opts.initialState };
+        this.convertToLlm = opts.convertToLlm || defaultConvertToLlm;
+        this.transformContext = opts.transformContext;
+        this.steeringMode = opts.steeringMode || "one-at-a-time";
+        this.followUpMode = opts.followUpMode || "one-at-a-time";
+        this.streamFn = opts.streamFn || streamSimple;
+        this._sessionId = opts.sessionId;
+        this.getApiKey = opts.getApiKey;
+        this._thinkingBudgets = opts.thinkingBudgets;
+    }
+    /**
+     * Get the current session ID used for provider caching.
+     */
+    get sessionId() {
+        return this._sessionId;
+    }
+    /**
+     * Set the session ID for provider caching.
+     * Call this when switching sessions (new session, branch, resume).
+     */
+    set sessionId(value) {
+        this._sessionId = value;
+    }
+    /**
+     * Get the current thinking budgets.
+     */
+    get thinkingBudgets() {
+        return this._thinkingBudgets;
+    }
+    /**
+     * Set custom thinking budgets for token-based providers.
+     */
+    set thinkingBudgets(value) {
+        this._thinkingBudgets = value;
+    }
+    get state() {
+        return this._state;
+    }
+    subscribe(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    // State mutators
+    setSystemPrompt(v) {
+        this._state.systemPrompt = v;
+    }
+    setModel(m) {
+        this._state.model = m;
+    }
+    setThinkingLevel(l) {
+        this._state.thinkingLevel = l;
+    }
+    setSteeringMode(mode) {
+        this.steeringMode = mode;
+    }
+    getSteeringMode() {
+        return this.steeringMode;
+    }
+    setFollowUpMode(mode) {
+        this.followUpMode = mode;
+    }
+    getFollowUpMode() {
+        return this.followUpMode;
+    }
+    setTools(t) {
+        this._state.tools = t;
+    }
+    replaceMessages(ms) {
+        this._state.messages = ms.slice();
+    }
+    appendMessage(m) {
+        this._state.messages = [...this._state.messages, m];
+    }
+    /**
+     * Queue a steering message to interrupt the agent mid-run.
+     * Delivered after current tool execution, skips remaining tools.
+     */
+    steer(m) {
+        this.steeringQueue.push(m);
+    }
+    /**
+     * Queue a follow-up message to be processed after the agent finishes.
+     * Delivered only when agent has no more tool calls or steering messages.
+     */
+    followUp(m) {
+        this.followUpQueue.push(m);
+    }
+    clearSteeringQueue() {
+        this.steeringQueue = [];
+    }
+    clearFollowUpQueue() {
+        this.followUpQueue = [];
+    }
+    clearAllQueues() {
+        this.steeringQueue = [];
+        this.followUpQueue = [];
+    }
+    clearMessages() {
+        this._state.messages = [];
+    }
+    abort() {
+        this.abortController?.abort();
+    }
+    waitForIdle() {
+        return this.runningPrompt ?? Promise.resolve();
+    }
+    reset() {
+        this._state.messages = [];
+        this._state.isStreaming = false;
+        this._state.streamMessage = null;
+        this._state.pendingToolCalls = new Set();
+        this._state.error = undefined;
+        this.steeringQueue = [];
+        this.followUpQueue = [];
+    }
+    async prompt(input, images) {
+        if (this._state.isStreaming) {
+            throw new Error("Agent is already processing a prompt. Use steer() or followUp() to queue messages, or wait for completion.");
+        }
+        const model = this._state.model;
+        if (!model)
+            throw new Error("No model configured");
+        let msgs;
+        if (Array.isArray(input)) {
+            msgs = input;
+        }
+        else if (typeof input === "string") {
+            const content = [{ type: "text", text: input }];
+            if (images && images.length > 0) {
+                content.push(...images);
+            }
+            msgs = [
+                {
+                    role: "user",
+                    content,
+                    timestamp: Date.now(),
+                },
+            ];
+        }
+        else {
+            msgs = [input];
+        }
+        await this._runLoop(msgs);
+    }
+    /** Continue from current context (for retry after overflow) */
+    async continue() {
+        if (this._state.isStreaming) {
+            throw new Error("Agent is already processing. Wait for completion before continuing.");
+        }
+        const messages = this._state.messages;
+        if (messages.length === 0) {
+            throw new Error("No messages to continue from");
+        }
+        if (messages[messages.length - 1].role === "assistant") {
+            throw new Error("Cannot continue from message role: assistant");
+        }
+        await this._runLoop(undefined);
+    }
+    /**
+     * Run the agent loop.
+     * If messages are provided, starts a new conversation turn with those messages.
+     * Otherwise, continues from existing context.
+     */
+    async _runLoop(messages) {
+        const model = this._state.model;
+        if (!model)
+            throw new Error("No model configured");
+        this.runningPrompt = new Promise((resolve) => {
+            this.resolveRunningPrompt = resolve;
+        });
+        this.abortController = new AbortController();
+        this._state.isStreaming = true;
+        this._state.streamMessage = null;
+        this._state.error = undefined;
+        const reasoning = this._state.thinkingLevel === "off" ? undefined : this._state.thinkingLevel;
+        const context = {
+            systemPrompt: this._state.systemPrompt,
+            messages: this._state.messages.slice(),
+            tools: this._state.tools,
+        };
+        const config = {
+            model,
+            reasoning,
+            sessionId: this._sessionId,
+            thinkingBudgets: this._thinkingBudgets,
+            convertToLlm: this.convertToLlm,
+            transformContext: this.transformContext,
+            getApiKey: this.getApiKey,
+            getSteeringMessages: async () => {
+                if (this.steeringMode === "one-at-a-time") {
+                    if (this.steeringQueue.length > 0) {
+                        const first = this.steeringQueue[0];
+                        this.steeringQueue = this.steeringQueue.slice(1);
+                        return [first];
+                    }
+                    return [];
+                }
+                else {
+                    const steering = this.steeringQueue.slice();
+                    this.steeringQueue = [];
+                    return steering;
+                }
+            },
+            getFollowUpMessages: async () => {
+                if (this.followUpMode === "one-at-a-time") {
+                    if (this.followUpQueue.length > 0) {
+                        const first = this.followUpQueue[0];
+                        this.followUpQueue = this.followUpQueue.slice(1);
+                        return [first];
+                    }
+                    return [];
+                }
+                else {
+                    const followUp = this.followUpQueue.slice();
+                    this.followUpQueue = [];
+                    return followUp;
+                }
+            },
+        };
+        let partial = null;
+        try {
+            const stream = messages
+                ? agentLoop(messages, context, config, this.abortController.signal, this.streamFn)
+                : agentLoopContinue(context, config, this.abortController.signal, this.streamFn);
+            for await (const event of stream) {
+                // Update internal state based on events
+                switch (event.type) {
+                    case "message_start":
+                        partial = event.message;
+                        this._state.streamMessage = event.message;
+                        break;
+                    case "message_update":
+                        partial = event.message;
+                        this._state.streamMessage = event.message;
+                        break;
+                    case "message_end":
+                        partial = null;
+                        this._state.streamMessage = null;
+                        this.appendMessage(event.message);
+                        break;
+                    case "tool_execution_start": {
+                        const s = new Set(this._state.pendingToolCalls);
+                        s.add(event.toolCallId);
+                        this._state.pendingToolCalls = s;
+                        break;
+                    }
+                    case "tool_execution_end": {
+                        const s = new Set(this._state.pendingToolCalls);
+                        s.delete(event.toolCallId);
+                        this._state.pendingToolCalls = s;
+                        break;
+                    }
+                    case "turn_end":
+                        if (event.message.role === "assistant" && event.message.errorMessage) {
+                            this._state.error = event.message.errorMessage;
+                        }
+                        break;
+                    case "agent_end":
+                        this._state.isStreaming = false;
+                        this._state.streamMessage = null;
+                        break;
+                }
+                // Emit to listeners
+                this.emit(event);
+            }
+            // Handle any remaining partial message
+            if (partial && partial.role === "assistant" && partial.content.length > 0) {
+                const onlyEmpty = !partial.content.some((c) => (c.type === "thinking" && c.thinking.trim().length > 0) ||
+                    (c.type === "text" && c.text.trim().length > 0) ||
+                    (c.type === "toolCall" && c.name.trim().length > 0));
+                if (!onlyEmpty) {
+                    this.appendMessage(partial);
+                }
+                else {
+                    if (this.abortController?.signal.aborted) {
+                        throw new Error("Request was aborted");
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const errorMsg = {
+                role: "assistant",
+                content: [{ type: "text", text: "" }],
+                api: model.api,
+                provider: model.provider,
+                model: model.id,
+                usage: {
+                    input: 0,
+                    output: 0,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                    totalTokens: 0,
+                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+                },
+                stopReason: this.abortController?.signal.aborted ? "aborted" : "error",
+                errorMessage: err?.message || String(err),
+                timestamp: Date.now(),
+            };
+            this.appendMessage(errorMsg);
+            this._state.error = err?.message || String(err);
+            this.emit({ type: "agent_end", messages: [errorMsg] });
+        }
+        finally {
+            this._state.isStreaming = false;
+            this._state.streamMessage = null;
+            this._state.pendingToolCalls = new Set();
+            this.abortController = undefined;
+            this.resolveRunningPrompt?.();
+            this.runningPrompt = undefined;
+            this.resolveRunningPrompt = undefined;
+        }
+    }
+    emit(e) {
+        for (const listener of this.listeners) {
+            listener(e);
+        }
+    }
+}

package/dist/agent/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./agent.js";
+export * from "./agent-loop.js";
+export * from "./proxy.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAE3B,cAAc,iBAAiB,CAAC;AAEhC,cAAc,YAAY,CAAC;AAE3B,cAAc,YAAY,CAAC"}

package/dist/agent/index.js

@@ -0,0 +1,8 @@
+// Core Agent
+export * from "./agent.js";
+// Loop functions
+export * from "./agent-loop.js";
+// Proxy utilities
+export * from "./proxy.js";
+// Types
+export * from "./types.js";

package/dist/agent/proxy.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Proxy stream function for apps that route LLM calls through a server.
+ * The server manages auth and proxies requests to LLM providers.
+ */
+import { type AssistantMessage, type AssistantMessageEvent, type Context, EventStream, type Model, type SimpleStreamOptions, type StopReason } from "../ai/index.js";
+declare class ProxyMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
+    constructor();
+}
+/**
+ * Proxy event types - server sends these with partial field stripped to reduce bandwidth.
+ */
+export type ProxyAssistantMessageEvent = {
+    type: "start";
+} | {
+    type: "text_start";
+    contentIndex: number;
+} | {
+    type: "text_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    type: "text_end";
+    contentIndex: number;
+    contentSignature?: string;
+} | {
+    type: "thinking_start";
+    contentIndex: number;
+} | {
+    type: "thinking_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    type: "thinking_end";
+    contentIndex: number;
+    contentSignature?: string;
+} | {
+    type: "toolcall_start";
+    contentIndex: number;
+    id: string;
+    toolName: string;
+} | {
+    type: "toolcall_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    type: "toolcall_end";
+    contentIndex: number;
+} | {
+    type: "done";
+    reason: Extract<StopReason, "stop" | "length" | "toolUse">;
+    usage: AssistantMessage["usage"];
+} | {
+    type: "error";
+    reason: Extract<StopReason, "aborted" | "error">;
+    errorMessage?: string;
+    usage: AssistantMessage["usage"];
+};
+export interface ProxyStreamOptions extends SimpleStreamOptions {
+    /** Auth token for the proxy server */
+    authToken: string;
+    /** Proxy server URL (e.g., "https://genai.example.com") */
+    proxyUrl: string;
+}
+/**
+ * Stream function that proxies through a server instead of calling LLM providers directly.
+ * The server strips the partial field from delta events to reduce bandwidth.
+ * We reconstruct the partial message client-side.
+ *
+ * Use this as the `streamFn` option when creating an Agent that needs to go through a proxy.
+ *
+ * @example
+ * ```typescript
+ * const agent = new Agent({
+ *   streamFn: (model, context, options) =>
+ *     streamProxy(model, context, {
+ *       ...options,
+ *       authToken: await getAuthToken(),
+ *       proxyUrl: "https://genai.example.com",
+ *     }),
+ * });
+ * ```
+ */
+export declare function streamProxy(model: Model<any>, context: Context, options: ProxyStreamOptions): ProxyMessageEventStream;
+export {};
+//# sourceMappingURL=proxy.d.ts.map

package/dist/agent/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/agent/proxy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,OAAO,EACZ,WAAW,EACX,KAAK,KAAK,EAEV,KAAK,mBAAmB,EACxB,KAAK,UAAU,EAEf,MAAM,gBAAgB,CAAC;AAGxB,cAAM,uBAAwB,SAAQ,WAAW,CAAC,qBAAqB,EAAE,gBAAgB,CAAC;;CAWzF;AAED;;GAEG;AACH,MAAM,MAAM,0BAA0B,GACnC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE,GACrE;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE,GACzE;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC9E;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAC9C;IACA,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC,CAAC;IAC3D,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CAChC,GACD;IACA,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,OAAO,CAAC,UAAU,EAAE,SAAS,GAAG,OAAO,CAAC,CAAC;IACjD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CAChC,CAAC;AAEL,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC9D,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,GAAG,uBAAuB,CAyHrH"}