@push.rocks/smartagent 1.8.0 → 3.0.1

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartagent',
-  version: '1.8.0',
-  description: 'an agentic framework built on top of @push.rocks/smartai'
+  version: '3.0.1',
+  description: 'Agentic loop for ai-sdk (Vercel AI SDK). Wraps streamText with stopWhen for parallel multi-step tool execution. Built on @push.rocks/smartai.'
 }

package/ts/index.ts

@@ -1,38 +1,11 @@
-import * as plugins from './plugins.js';
-
-// Export the dual-agent orchestrator (main entry point)
-export { DualAgentOrchestrator } from './smartagent.classes.dualagent.js';
-
-// Export individual agents
-export { DriverAgent } from './smartagent.classes.driveragent.js';
-export { GuardianAgent } from './smartagent.classes.guardianagent.js';
-
-// Export tool registry and related classes
+export { runAgent } from './smartagent.classes.agent.js';
 export { ToolRegistry } from './smartagent.classes.toolregistry.js';
-
-// Export base tool class for custom tool creation
-export { BaseToolWrapper } from './smartagent.tools.base.js';
-
-// Export standard tools
-export { FilesystemTool, type IFilesystemToolOptions } from './smartagent.tools.filesystem.js';
-export { HttpTool } from './smartagent.tools.http.js';
-export { ShellTool } from './smartagent.tools.shell.js';
-export { BrowserTool } from './smartagent.tools.browser.js';
-export { DenoTool, type TDenoPermission } from './smartagent.tools.deno.js';
-export { JsonValidatorTool } from './smartagent.tools.json.js';
-
-// Export tool search and expert tools
-export { ToolSearchTool } from './smartagent.tools.search.js';
-export { ExpertTool } from './smartagent.tools.expert.js';
-
-// Export all interfaces
-export * from './smartagent.interfaces.js';
-
-// Re-export useful types from smartai
-export {
-  type ISmartAiOptions,
-  type TProvider,
-  type ChatMessage,
-  type ChatOptions,
-  type ChatResponse,
-} from '@push.rocks/smartai';
+export { truncateOutput } from './smartagent.utils.truncation.js';
+export type { ITruncateResult } from './smartagent.utils.truncation.js';
+export { ContextOverflowError } from './smartagent.interfaces.js';
+export type { IAgentRunOptions, IAgentRunResult } from './smartagent.interfaces.js';
+
+// Re-export tool() and z so consumers can define tools without extra imports
+export { tool, jsonSchema } from '@push.rocks/smartai';
+export { z } from 'zod';
+export { stepCountIs } from 'ai';

package/ts/plugins.ts

@@ -3,24 +3,25 @@ import * as path from 'path';
 
 export { path };
 
-// third party
-import { minimatch } from 'minimatch';
-
-export { minimatch };
-
-// @push.rocks scope
-import * as smartai from '@push.rocks/smartai';
-import * as smartdeno from '@push.rocks/smartdeno';
-import * as smartfs from '@push.rocks/smartfs';
-import * as smartrequest from '@push.rocks/smartrequest';
-import * as smartbrowser from '@push.rocks/smartbrowser';
-import * as smartshell from '@push.rocks/smartshell';
-
-export {
-  smartai,
-  smartdeno,
-  smartfs,
-  smartrequest,
-  smartbrowser,
-  smartshell,
-};
+// ai-sdk core
+import { streamText, generateText, stepCountIs } from 'ai';
+
+export { streamText, generateText, stepCountIs };
+
+export type {
+  ModelMessage,
+  ToolSet,
+  StreamTextResult,
+} from 'ai';
+
+// @push.rocks/smartai
+import { tool, jsonSchema } from '@push.rocks/smartai';
+
+export { tool, jsonSchema };
+
+export type { LanguageModelV3 } from '@push.rocks/smartai';
+
+// zod
+import { z } from 'zod';
+
+export { z };

package/ts/smartagent.classes.agent.ts

@@ -0,0 +1,198 @@
+// Retry backoff and context overflow logic derived from opencode (MIT) — https://github.com/sst/opencode
+
+import * as plugins from './plugins.js';
+import type { IAgentRunOptions, IAgentRunResult } from './smartagent.interfaces.js';
+import { ContextOverflowError } from './smartagent.interfaces.js';
+
+// Retry constants
+const RETRY_INITIAL_DELAY = 2000;
+const RETRY_BACKOFF_FACTOR = 2;
+const RETRY_MAX_DELAY = 30_000;
+const MAX_RETRY_ATTEMPTS = 8;
+
+function retryDelay(attempt: number, headers?: Record<string, string>): number {
+  if (headers) {
+    const ms = headers['retry-after-ms'];
+    if (ms) {
+      const n = parseFloat(ms);
+      if (!isNaN(n)) return n;
+    }
+    const after = headers['retry-after'];
+    if (after) {
+      const secs = parseFloat(after);
+      if (!isNaN(secs)) return Math.ceil(secs * 1000);
+      const date = Date.parse(after) - Date.now();
+      if (!isNaN(date) && date > 0) return Math.ceil(date);
+    }
+  }
+  return Math.min(
+    RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1),
+    RETRY_MAX_DELAY,
+  );
+}
+
+async function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException('Aborted', 'AbortError'));
+      return;
+    }
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(t);
+        reject(new DOMException('Aborted', 'AbortError'));
+      },
+      { once: true },
+    );
+  });
+}
+
+function isRetryableError(err: unknown): boolean {
+  const status = (err as any)?.status ?? (err as any)?.statusCode;
+  if (status === 429 || status === 529 || status === 503) return true;
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    if (msg.includes('rate limit') || msg.includes('overloaded') || msg.includes('too many requests')) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function isContextOverflow(err: unknown): boolean {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return (
+      msg.includes('context_length_exceeded') ||
+      msg.includes('context window') ||
+      msg.includes('maximum context length') ||
+      msg.includes('too many tokens') ||
+      msg.includes('input is too long') ||
+      (err as any)?.name === 'AI_ContextWindowExceededError'
+    );
+  }
+  return false;
+}
+
+export async function runAgent(options: IAgentRunOptions): Promise<IAgentRunResult> {
+  let stepCount = 0;
+  let attempt = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+
+  const tools = options.tools ?? {};
+
+  // Add a no-op sink for repaired-but-unrecognised tool calls
+  const allTools: plugins.ToolSet = {
+    ...tools,
+    invalid: plugins.tool({
+      description: 'Sink for unrecognised tool calls — returns an error message to the model',
+      inputSchema: plugins.z.object({
+        tool: plugins.z.string(),
+        error: plugins.z.string(),
+      }),
+      execute: async ({ tool, error }: { tool: string; error: string }) =>
+        `Unknown tool "${tool}": ${error}`,
+    }),
+  };
+
+  // Build messages — streamText requires either prompt OR messages, not both
+  let messages: plugins.ModelMessage[] = options.messages
+    ? [...options.messages, { role: 'user' as const, content: options.prompt }]
+    : [{ role: 'user' as const, content: options.prompt }];
+
+  while (true) {
+    try {
+      const result = plugins.streamText({
+        model: options.model,
+        system: options.system,
+        messages,
+        tools: allTools,
+        stopWhen: plugins.stepCountIs(options.maxSteps ?? 20),
+        maxRetries: 0, // handled manually below
+        abortSignal: options.abort,
+
+        experimental_repairToolCall: async ({ toolCall, tools: availableTools, error }) => {
+          const lower = toolCall.toolName.toLowerCase();
+          if (lower !== toolCall.toolName && (availableTools as any)[lower]) {
+            return { ...toolCall, toolName: lower };
+          }
+          return {
+            ...toolCall,
+            toolName: 'invalid',
+            args: JSON.stringify({
+              tool: toolCall.toolName,
+              error: String(error),
+            }),
+          };
+        },
+
+        onChunk: ({ chunk }) => {
+          if (chunk.type === 'text-delta' && options.onToken) {
+            options.onToken((chunk as any).textDelta ?? (chunk as any).text ?? '');
+          }
+        },
+
+        experimental_onToolCallStart: options.onToolCall
+          ? ({ toolCall }) => {
+              options.onToolCall!(toolCall.toolName, (toolCall as any).input ?? (toolCall as any).args);
+            }
+          : undefined,
+
+        experimental_onToolCallFinish: options.onToolResult
+          ? ({ toolCall }) => {
+              options.onToolResult!(toolCall.toolName, (toolCall as any).result);
+            }
+          : undefined,
+
+        onStepFinish: ({ usage }) => {
+          stepCount++;
+          totalInput += usage?.inputTokens ?? 0;
+          totalOutput += usage?.outputTokens ?? 0;
+        },
+      });
+
+      // Consume the stream and collect results
+      const text = await result.text;
+      const finishReason = await result.finishReason;
+      const responseData = await result.response;
+
+      attempt = 0; // reset on success
+
+      return {
+        text,
+        messages: responseData.messages as plugins.ModelMessage[],
+        steps: stepCount,
+        finishReason,
+        usage: {
+          inputTokens: totalInput,
+          outputTokens: totalOutput,
+          totalTokens: totalInput + totalOutput,
+        },
+      };
+    } catch (err: unknown) {
+      // Abort — don't retry
+      if (err instanceof DOMException && err.name === 'AbortError') throw err;
+
+      // Rate limit / overload — retry with backoff
+      if (isRetryableError(err) && attempt < MAX_RETRY_ATTEMPTS) {
+        attempt++;
+        const headers = (err as any)?.responseHeaders ?? (err as any)?.headers;
+        const delay = retryDelay(attempt, headers);
+        await sleep(delay, options.abort);
+        continue;
+      }
+
+      // Context overflow — compact and retry if handler provided
+      if (isContextOverflow(err)) {
+        if (!options.onContextOverflow) throw new ContextOverflowError();
+        messages = await options.onContextOverflow(messages);
+        continue;
+      }
+
+      throw err;
+    }
+  }
+}

package/ts/smartagent.classes.toolregistry.ts

@@ -1,188 +1,20 @@
-import * as interfaces from './smartagent.interfaces.js';
-import { BaseToolWrapper } from './smartagent.tools.base.js';
+import type { ToolSet } from './plugins.js';
 
-/**
- * ToolRegistry - Manages tool registration, visibility, and lifecycle
- *
- * Responsibilities:
- * - Track all registered tools with their metadata
- * - Manage visibility (initial vs on-demand)
- * - Handle activation of on-demand tools
- * - Provide search functionality
- */
 export class ToolRegistry {
-  private tools: Map<string, BaseToolWrapper> = new Map();
-  private metadata: Map<string, interfaces.IToolMetadata> = new Map();
-  private activated: Set<string> = new Set();
+  private tools: ToolSet = {};
 
   /**
-   * Register a tool with optional visibility settings
+   * Register a tool.
+   * @param name  Tool name (must be unique, snake_case recommended)
+   * @param def   Tool definition created with ai-sdk's tool() helper
    */
-  register(tool: BaseToolWrapper, options: interfaces.IToolRegistrationOptions = {}): void {
-    const visibility = options.visibility ?? 'initial';
-
-    this.tools.set(tool.name, tool);
-    this.metadata.set(tool.name, {
-      name: tool.name,
-      description: tool.description,
-      actions: tool.actions,
-      visibility,
-      isActivated: visibility === 'initial',
-      isInitialized: false,
-      tags: options.tags,
-      category: options.category,
-    });
-
-    if (visibility === 'initial') {
-      this.activated.add(tool.name);
-    }
-  }
-
-  /**
-   * Get tools visible to the Driver (initial + activated on-demand)
-   */
-  getVisibleTools(): BaseToolWrapper[] {
-    return Array.from(this.tools.entries())
-      .filter(([name]) => this.activated.has(name))
-      .map(([, tool]) => tool);
-  }
-
-  /**
-   * Get all tools (for search results)
-   */
-  getAllTools(): BaseToolWrapper[] {
-    return Array.from(this.tools.values());
-  }
-
-  /**
-   * Get a specific tool by name
-   */
-  getTool(name: string): BaseToolWrapper | undefined {
-    return this.tools.get(name);
+  public register(name: string, def: ToolSet[string]): this {
+    this.tools[name] = def;
+    return this;
   }
 
-  /**
-   * Get metadata for a tool
-   */
-  getMetadata(name: string): interfaces.IToolMetadata | undefined {
-    return this.metadata.get(name);
-  }
-
-  /**
-   * Get all metadata
-   */
-  getAllMetadata(): interfaces.IToolMetadata[] {
-    return Array.from(this.metadata.values());
-  }
-
-  /**
-   * Search tools by query (matches name, description, tags, action names)
-   */
-  search(query: string): interfaces.IToolMetadata[] {
-    const q = query.toLowerCase();
-    return this.getAllMetadata().filter((meta) => {
-      if (meta.name.toLowerCase().includes(q)) return true;
-      if (meta.description.toLowerCase().includes(q)) return true;
-      if (meta.tags?.some((t) => t.toLowerCase().includes(q))) return true;
-      if (meta.category?.toLowerCase().includes(q)) return true;
-      if (
-        meta.actions.some(
-          (a) => a.name.toLowerCase().includes(q) || a.description.toLowerCase().includes(q)
-        )
-      )
-        return true;
-      return false;
-    });
-  }
-
-  /**
-   * Activate an on-demand tool
-   */
-  async activate(name: string): Promise<{ success: boolean; error?: string }> {
-    const tool = this.tools.get(name);
-    const meta = this.metadata.get(name);
-
-    if (!tool || !meta) {
-      return { success: false, error: `Tool "${name}" not found` };
-    }
-
-    if (this.activated.has(name)) {
-      return { success: true }; // Already activated
-    }
-
-    // Initialize if not already initialized
-    if (!meta.isInitialized) {
-      await tool.initialize();
-      meta.isInitialized = true;
-    }
-
-    this.activated.add(name);
-    meta.isActivated = true;
-
-    return { success: true };
-  }
-
-  /**
-   * Check if a tool is activated
-   */
-  isActivated(name: string): boolean {
-    return this.activated.has(name);
-  }
-
-  /**
-   * Initialize all initial (visible) tools
-   */
-  async initializeVisibleTools(): Promise<void> {
-    const promises: Promise<void>[] = [];
-
-    for (const [name, tool] of this.tools) {
-      const meta = this.metadata.get(name);
-      if (meta && this.activated.has(name) && !meta.isInitialized) {
-        promises.push(
-          tool.initialize().then(() => {
-            meta.isInitialized = true;
-          })
-        );
-      }
-    }
-
-    await Promise.all(promises);
-  }
-
-  /**
-   * Cleanup all initialized tools
-   */
-  async cleanup(): Promise<void> {
-    const promises: Promise<void>[] = [];
-
-    for (const [name, tool] of this.tools) {
-      const meta = this.metadata.get(name);
-      if (meta?.isInitialized) {
-        promises.push(tool.cleanup());
-      }
-    }
-
-    await Promise.all(promises);
-  }
-
-  /**
-   * Check if a tool exists in the registry
-   */
-  has(name: string): boolean {
-    return this.tools.has(name);
-  }
-
-  /**
-   * Get the number of registered tools
-   */
-  get size(): number {
-    return this.tools.size;
-  }
-
-  /**
-   * Get the number of activated tools
-   */
-  get activatedCount(): number {
-    return this.activated.size;
+  /** Get the full ToolSet for passing to runAgent */
+  public getTools(): ToolSet {
+    return { ...this.tools };
   }
 }