@contractspec/module.ai-chat 3.2.0 → 4.0.0

package/dist/core/index.js

@@ -130,6 +130,9 @@ class ChatService {
   systemPrompt;
   maxHistoryMessages;
   onUsage;
+  tools;
+  sendReasoning;
+  sendSources;
   constructor(config) {
     this.provider = config.provider;
     this.context = config.context;
@@ -137,6 +140,9 @@ class ChatService {
     this.systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.maxHistoryMessages = config.maxHistoryMessages ?? 20;
     this.onUsage = config.onUsage;
+    this.tools = config.tools;
+    this.sendReasoning = config.sendReasoning ?? false;
+    this.sendSources = config.sendSources ?? false;
   }
   async send(options) {
     let conversation;
@@ -161,13 +167,14 @@ class ChatService {
       status: "completed",
       attachments: options.attachments
     });
-    const prompt = this.buildPrompt(conversation, options);
+    const messages = this.buildMessages(conversation, options);
     const model = this.provider.getModel();
     try {
       const result = await generateText({
         model,
-        prompt,
-        system: this.systemPrompt
+        messages,
+        system: this.systemPrompt,
+        tools: this.tools
       });
       const assistantMessage = await this.store.appendMessage(conversation.id, {
         role: "assistant",
@@ -223,33 +230,106 @@ class ChatService {
       content: "",
       status: "streaming"
     });
-    const prompt = this.buildPrompt(conversation, options);
+    const messages = this.buildMessages(conversation, options);
     const model = this.provider.getModel();
-    const self = {
-      systemPrompt: this.systemPrompt,
-      store: this.store
-    };
+    const systemPrompt = this.systemPrompt;
+    const tools = this.tools;
+    const store = this.store;
+    const onUsage = this.onUsage;
     async function* streamGenerator() {
       let fullContent = "";
+      let fullReasoning = "";
+      const toolCallsMap = new Map;
+      const sources = [];
       try {
         const result = streamText({
           model,
-          prompt,
-          system: self.systemPrompt
+          messages,
+          system: systemPrompt,
+          tools
         });
-        for await (const chunk of result.textStream) {
-          fullContent += chunk;
-          yield { type: "text", content: chunk };
+        for await (const part of result.fullStream) {
+          if (part.type === "text-delta") {
+            const text = part.text ?? "";
+            if (text) {
+              fullContent += text;
+              yield { type: "text", content: text };
+            }
+          } else if (part.type === "reasoning-delta") {
+            const text = part.text ?? "";
+            if (text) {
+              fullReasoning += text;
+              yield { type: "reasoning", content: text };
+            }
+          } else if (part.type === "source") {
+            const src = part;
+            const source = {
+              id: src.id,
+              title: src.title ?? "",
+              url: src.url,
+              type: "web"
+            };
+            sources.push(source);
+            yield { type: "source", source };
+          } else if (part.type === "tool-call") {
+            const toolCall = {
+              id: part.toolCallId,
+              name: part.toolName,
+              args: part.input ?? {},
+              status: "running"
+            };
+            toolCallsMap.set(part.toolCallId, toolCall);
+            yield { type: "tool_call", toolCall };
+          } else if (part.type === "tool-result") {
+            const tc = toolCallsMap.get(part.toolCallId);
+            if (tc) {
+              tc.result = part.output;
+              tc.status = "completed";
+            }
+            yield {
+              type: "tool_result",
+              toolResult: {
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                result: part.output
+              }
+            };
+          } else if (part.type === "tool-error") {
+            const tc = toolCallsMap.get(part.toolCallId);
+            if (tc) {
+              tc.status = "error";
+              tc.error = part.error ?? "Tool execution failed";
+            }
+          } else if (part.type === "finish") {
+            const usage = part.usage;
+            const inputTokens = usage?.inputTokens ?? 0;
+            const outputTokens = usage?.completionTokens ?? 0;
+            await store.updateMessage(conversation.id, assistantMessage.id, {
+              content: fullContent,
+              status: "completed",
+              reasoning: fullReasoning || undefined,
+              sources: sources.length > 0 ? sources : undefined,
+              toolCalls: toolCallsMap.size > 0 ? Array.from(toolCallsMap.values()) : undefined,
+              usage: usage ? { inputTokens, outputTokens } : undefined
+            });
+            onUsage?.({ inputTokens, outputTokens });
+            yield {
+              type: "done",
+              usage: usage ? { inputTokens, outputTokens } : undefined
+            };
+            return;
+          }
         }
-        await self.store.updateMessage(conversation.id, assistantMessage.id, {
+        await store.updateMessage(conversation.id, assistantMessage.id, {
           content: fullContent,
-          status: "completed"
+          status: "completed",
+          reasoning: fullReasoning || undefined,
+          sources: sources.length > 0 ? sources : undefined,
+          toolCalls: toolCallsMap.size > 0 ? Array.from(toolCallsMap.values()) : undefined
         });
-        yield {
-          type: "done"
-        };
+        yield { type: "done" };
       } catch (error) {
-        await self.store.updateMessage(conversation.id, assistantMessage.id, {
+        await store.updateMessage(conversation.id, assistantMessage.id, {
           content: fullContent,
           status: "error",
           error: {
@@ -284,48 +364,128 @@ class ChatService {
   async deleteConversation(conversationId) {
     return this.store.delete(conversationId);
   }
-  buildPrompt(conversation, options) {
-    let prompt = "";
+  buildMessages(conversation, _options) {
     const historyStart = Math.max(0, conversation.messages.length - this.maxHistoryMessages);
+    const messages = [];
     for (let i = historyStart;i < conversation.messages.length; i++) {
       const msg = conversation.messages[i];
       if (!msg)
         continue;
-      if (msg.role === "user" || msg.role === "assistant") {
-        prompt += `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}
-
-`;
-      }
-    }
-    let content = options.content;
-    if (options.attachments?.length) {
-      const attachmentInfo = options.attachments.map((a) => {
-        if (a.type === "file" || a.type === "code") {
-          return `
+      if (msg.role === "user") {
+        let content = msg.content;
+        if (msg.attachments?.length) {
+          const attachmentInfo = msg.attachments.map((a) => {
+            if (a.type === "file" || a.type === "code") {
+              return `
 
 ### ${a.name}
 \`\`\`
-${a.content}
+${a.content ?? ""}
 \`\`\``;
-        }
-        return `
+            }
+            return `
 
 [Attachment: ${a.name}]`;
-      }).join("");
-      content += attachmentInfo;
+          }).join("");
+          content += attachmentInfo;
+        }
+        messages.push({ role: "user", content });
+      } else if (msg.role === "assistant") {
+        if (msg.toolCalls?.length) {
+          messages.push({
+            role: "assistant",
+            content: msg.content || "",
+            toolCalls: msg.toolCalls.map((tc) => ({
+              type: "tool-call",
+              toolCallId: tc.id,
+              toolName: tc.name,
+              args: tc.args
+            }))
+          });
+          messages.push({
+            role: "tool",
+            content: msg.toolCalls.map((tc) => ({
+              type: "tool-result",
+              toolCallId: tc.id,
+              toolName: tc.name,
+              output: tc.result
+            }))
+          });
+        } else {
+          messages.push({ role: "assistant", content: msg.content });
+        }
+      }
     }
-    prompt += `User: ${content}
-
-Assistant:`;
-    return prompt;
+    return messages;
   }
 }
 function createChatService(config) {
   return new ChatService(config);
 }
+// src/core/create-chat-route.ts
+import {
+  convertToModelMessages,
+  streamText as streamText2
+} from "ai";
+var DEFAULT_SYSTEM_PROMPT2 = `You are a helpful AI assistant.`;
+function createChatRoute(options) {
+  const { provider, systemPrompt = DEFAULT_SYSTEM_PROMPT2, tools } = options;
+  return async (req) => {
+    if (req.method !== "POST") {
+      return new Response("Method not allowed", { status: 405 });
+    }
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return new Response("Invalid JSON body", { status: 400 });
+    }
+    const messages = body.messages ?? [];
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return new Response("messages array required", { status: 400 });
+    }
+    const model = provider.getModel();
+    const result = streamText2({
+      model,
+      messages: await convertToModelMessages(messages),
+      system: systemPrompt,
+      tools
+    });
+    return result.toUIMessageStreamResponse();
+  };
+}
+// src/core/create-completion-route.ts
+import { streamText as streamText3 } from "ai";
+function createCompletionRoute(options) {
+  const { provider, systemPrompt } = options;
+  return async (req) => {
+    if (req.method !== "POST") {
+      return new Response("Method not allowed", { status: 405 });
+    }
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      return new Response("Invalid JSON body", { status: 400 });
+    }
+    const prompt = body.prompt ?? "";
+    if (!prompt || typeof prompt !== "string") {
+      return new Response("prompt string required", { status: 400 });
+    }
+    const model = provider.getModel();
+    const result = streamText3({
+      model,
+      prompt,
+      system: systemPrompt
+    });
+    return result.toTextStreamResponse();
+  };
+}
 export {
   createInMemoryConversationStore,
+  createCompletionRoute,
   createChatService,
+  createChatRoute,
   InMemoryConversationStore,
   ChatService
 };

package/dist/core/message-types.d.ts

@@ -113,12 +113,21 @@ export interface SendMessageOptions {
     stream?: boolean;
 }
 /**
- * Streaming chunk from AI response
+ * Streaming chunk from AI response (maps from AI SDK fullStream parts)
  */
 export interface ChatStreamChunk {
-    type: 'text' | 'reasoning' | 'tool_call' | 'source' | 'error' | 'done';
+    type: 'text' | 'reasoning' | 'tool_call' | 'tool_result' | 'source' | 'error' | 'done';
+    /** Text delta (for type 'text') */
     content?: string;
+    /** Tool call (for type 'tool_call') */
     toolCall?: ChatToolCall;
+    /** Tool result (for type 'tool_result') */
+    toolResult?: {
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+    };
+    /** Source/citation (for type 'source') */
     source?: ChatSource;
     error?: {
         code: string;