@liquidmetal-ai/precip 1.0.0

package/src/engine/stream-parser.ts

@@ -0,0 +1,170 @@
+/**
+ * Streaming Response Parser - Shared logic for parsing OpenAI-format streams
+ *
+ * Both OpenAIProvider and LiquidmetalProvider use OpenAI-compatible streaming formats.
+ * This shared parser eliminates ~100 lines of duplication.
+ */
+
+import type { LLMResponse, LLMToolCall, Logger } from '../types.js';
+
+/**
+ * Parse an OpenAI-compatible streaming response
+ *
+ * Handles:
+ * - Standard OpenAI format: { choices: [{ delta: { content }, tool_calls: [...] }] }
+ * - DeepSeek-R1 format: { response: "..." }
+ * - Tool call accumulation across multiple chunks
+ */
+export async function parseOpenAIStream(
+  stream: ReadableStream,
+  logger?: Logger,
+  deepSeekMode = false
+): Promise<LLMResponse> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  const toolCallsMap = new Map<number, LLMToolCall>();
+  let content = '';
+  let finishReason: string | null = null;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.trim() || line.trim() === 'data: [DONE]') continue;
+
+        const jsonStr = line.replace(/^data: /, '').trim();
+        if (!jsonStr) continue;
+
+        try {
+          const chunk = JSON.parse(jsonStr);
+
+          // Check for error responses from the AI service
+          if (chunk.error) {
+            throw new Error(
+              `AI service error: ${chunk.error.message || JSON.stringify(chunk.error)}`
+            );
+          }
+
+          // Handle DeepSeek-R1 streaming format: {"response": "..."}
+          if (deepSeekMode && chunk.response !== undefined) {
+            content += chunk.response;
+            continue;
+          }
+
+          // Handle OpenAI-compatible format: {"choices": [...]}
+          const choice = chunk.choices?.[0];
+          if (!choice) {
+            continue;
+          }
+
+          // Accumulate content
+          if (choice.delta?.content) {
+            content += choice.delta.content;
+          }
+
+          // Accumulate tool calls
+          if (choice.delta?.tool_calls) {
+            for (const toolCallDelta of choice.delta.tool_calls) {
+              const index = toolCallDelta.index;
+
+              if (!toolCallsMap.has(index)) {
+                toolCallsMap.set(index, {
+                  id: toolCallDelta.id || '',
+                  type: 'function',
+                  function: {
+                    name: toolCallDelta.function?.name || '',
+                    arguments: toolCallDelta.function?.arguments || ''
+                  }
+                });
+              } else {
+                const existing = toolCallsMap.get(index)!;
+                if (toolCallDelta.function?.arguments) {
+                  existing.function.arguments += toolCallDelta.function?.arguments;
+                }
+              }
+            }
+          }
+
+          if (choice.finish_reason) {
+            finishReason = choice.finish_reason;
+          }
+        } catch (e) {
+          logger?.warn?.('Failed to parse streaming chunk', {
+            error: (e as Error).message,
+            jsonStr: jsonStr.substring(0, 200)
+          });
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  // Validate accumulated tool call arguments are valid JSON
+  if (toolCallsMap.size > 0) {
+    for (const [index, toolCall] of toolCallsMap.entries()) {
+      if (toolCall.function.arguments) {
+        try {
+          JSON.parse(toolCall.function.arguments);
+        } catch (_e) {
+          logger?.error?.(
+            `Invalid JSON in tool call ${index} (${toolCall.function.name}): ${toolCall.function.arguments.substring(0, 200)}`
+          );
+          // Remove the invalid tool call to prevent downstream errors
+          toolCallsMap.delete(index);
+        }
+      }
+    }
+  }
+
+  return {
+    content: content || null,
+    toolCalls: Array.from(toolCallsMap.values()),
+    finishReason
+  };
+}
+
+/**
+ * Parse a non-streaming OpenAI-compatible response
+ */
+export function parseOpenAIResponse(data: any): LLMResponse {
+  if (!data) {
+    return {
+      content: null,
+      toolCalls: [],
+      finishReason: 'error'
+    };
+  }
+
+  if (!data.choices || data.choices.length === 0) {
+    return {
+      content: null,
+      toolCalls: [],
+      finishReason: 'error'
+    };
+  }
+
+  const choice = data.choices[0];
+  const message = choice?.message;
+
+  return {
+    content: message?.content || null,
+    toolCalls: message?.tool_calls || [],
+    finishReason: choice?.finish_reason || null,
+    usage: data.usage
+      ? {
+          promptTokens: data.usage.prompt_tokens,
+          completionTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens
+        }
+      : undefined
+  };
+}

package/src/index.ts

@@ -0,0 +1,142 @@
+/**
+ * Precip - Agent SDK for Raindrop
+ *
+ * Build sophisticated LLM-powered agents with tool calling and sandboxed code execution
+ */
+
+// Core Agent
+export { PrecipAgent } from './engine/agent.js';
+
+// LLM Provider
+export { createLLMProvider } from './engine/llm-provider.js';
+
+// Mounts
+export { MountManager } from './mounts/mount-manager.js';
+
+// Tools
+export { ToolRegistry } from './tools/registry.js';
+export {
+  FileTools,
+  ReadFileTool,
+  WriteFileTool,
+  ListFilesTool,
+  DeleteFileTool
+} from './tools/file-tools.js';
+export { SqlTools, SqlQueryTool, SqlExecuteTool, SqlBatchTool } from './tools/sql-tools.js';
+export { CodeTools, CodeExecutionTool, createCodeExecutionTool, createMountGlobals } from './tools/code-tools.js';
+export type { CodeToolOptions } from './tools/code-tools.js';
+export {
+  ScriptTools,
+  ScriptExecutionTool,
+  createScriptExecutionTool
+} from './tools/script-tools.js';
+export type { ScriptToolOptions } from './tools/script-tools.js';
+export {
+  SmartBucketTools,
+  SemanticSearchTool,
+  ChunkSearchTool,
+  GetSearchPageTool
+} from './tools/smartbucket-tools.js';
+export {
+  ActorStorageTools,
+  ReadStateTool,
+  WriteStateTool,
+  ListStateTool,
+  DeleteStateTool
+} from './tools/actor-storage-tools.js';
+
+// Sandbox
+export { Sandbox } from './sandbox/index.js';
+
+// Skills
+export { discoverSkills, generateSkillsPrompt, parseFrontmatter } from './skills/index.js';
+export type { SkillMetadata, SkillsConfig, SkillFrontmatter } from './skills/index.js';
+
+// Presets
+export { ScriptAgentTools, ToolAgentTools } from './presets/index.js';
+
+// Types
+export type {
+  // LLM Types
+  LLMProvider,
+  LLMConfig,
+  LLMMessage,
+  LLMResponse,
+  LLMToolCall,
+
+  // Mount Types
+  MountConfig,
+  MountConfigType,
+  MountInfo,
+  MountType,
+  MountMode,
+  ParsedPath,
+
+  // Mount Config Types
+  BucketMountConfig,
+  SmartBucketMountConfig,
+  KvMountConfig,
+  SqlMountConfig,
+  ActorMountConfig,
+  ActorStorageMountConfig,
+  ActorMethodSchema,
+  BucketMountInfo,
+  SmartBucketMountInfo,
+  KvMountInfo,
+  SqlMountInfo,
+  ActorMountInfo,
+  ActorStorageMountInfo,
+
+  // Tool Types
+  Tool,
+  ToolDefinition,
+  ToolParameter,
+  ToolContext,
+  ToolResult,
+  ToolClass,
+
+  // Agent Types
+  AgentConfig,
+  AgentResponse,
+  AgentEvent,
+  AgentEventType,
+  ToolCallResult,
+  ConversationState,
+  RetryConfig,
+
+  // Sandbox Types
+  SandboxResult,
+  SandboxOptions,
+  SandboxGlobals,
+  SandboxGlobal,
+  AsyncSandboxGlobal,
+  SyncSandboxGlobal,
+  ObjectSandboxGlobal,
+
+  // Logger
+  Logger
+} from './types.js';
+// Sandbox global helpers
+export { sandboxAsync, sandboxSync, sandboxObject } from './types.js';
+export type { BridgeInstaller } from './sandbox/bridges/types.js';
+// Utilities
+export { zodToTypeString } from './mounts/zod-to-string.js';
+
+/**
+ * Helper to create a custom tool
+ */
+export function createTool(config: {
+  name: string;
+  description: string;
+  parameters: Record<string, any>;
+  execute: (params: any, context: any) => Promise<any>;
+}): any {
+  return {
+    definition: {
+      name: config.name,
+      description: config.description,
+      parameters: config.parameters
+    },
+    execute: config.execute
+  };
+}