plugin-ai-api 1.0.9 → 1.0.10

package/dist/server/utils/streaming.js

@@ -0,0 +1,80 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streaming_exports = {};
+__export(streaming_exports, {
+  createRequestAbortController: () => createRequestAbortController,
+  isStreamingRequested: () => isStreamingRequested,
+  writeResponse: () => writeResponse
+});
+module.exports = __toCommonJS(streaming_exports);
+function isStreamingRequested(value) {
+  return value !== false;
+}
+function createRequestAbortController(ctx) {
+  const controller = new AbortController();
+  const abort = () => {
+    if (!ctx.res.writableEnded) controller.abort(new Error("Client disconnected"));
+  };
+  ctx.req.once("aborted", abort);
+  ctx.res.once("close", abort);
+  return {
+    signal: controller.signal,
+    dispose() {
+      ctx.req.off("aborted", abort);
+      ctx.res.off("close", abort);
+    }
+  };
+}
+async function writeResponse(ctx, data) {
+  if (ctx.res.writableEnded || ctx.res.destroyed) return false;
+  if (!ctx.res.write(data)) await waitForDrain(ctx);
+  return true;
+}
+function waitForDrain(ctx) {
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      ctx.res.off("drain", onDrain);
+      ctx.res.off("close", onClose);
+    };
+    const onDrain = () => {
+      cleanup();
+      resolve();
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("Client disconnected"));
+    };
+    ctx.res.once("drain", onDrain);
+    ctx.res.once("close", onClose);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRequestAbortController,
+  isStreamingRequested,
+  writeResponse
+});

package/dist/swagger.js

@@ -183,7 +183,7 @@ var swagger_default = {
                   model: { type: "string" },
                   prompt: { type: "string" },
                   max_tokens: { type: "integer" },
-                  stream: { type: "boolean", default: false }
+                  stream: { type: "boolean", default: true }
                 },
                 required: ["model", "prompt"]
               }
@@ -294,7 +294,9 @@ var swagger_default = {
         properties: {
           role: { type: "string", enum: ["system", "user", "assistant", "tool"] },
           content: { type: "string" },
-          name: { type: "string" }
+          name: { type: "string" },
+          tool_call_id: { type: "string" },
+          tool_calls: { type: "array", items: { $ref: "#/components/schemas/ToolCall" } }
         },
         required: ["role", "content"]
       },
@@ -303,12 +305,17 @@ var swagger_default = {
         properties: {
           model: { type: "string", example: "openai/gpt-4o" },
           messages: { type: "array", items: { $ref: "#/components/schemas/ChatMessage" } },
-          stream: { type: "boolean", default: false },
+          stream: { type: "boolean", default: true },
           temperature: { type: "number", minimum: 0, maximum: 2 },
           max_tokens: { type: "integer" },
           top_p: { type: "number" },
           frequency_penalty: { type: "number" },
-          presence_penalty: { type: "number" }
+          presence_penalty: { type: "number" },
+          tools: { type: "array", items: { $ref: "#/components/schemas/ToolDefinition" } },
+          tool_choice: {
+            description: "OpenAI-compatible tool choice: auto, none, required, or a named function choice.",
+            oneOf: [{ type: "string", enum: ["auto", "none", "required"] }, { type: "object" }]
+          }
         },
         required: ["model", "messages"]
       },
@@ -339,6 +346,33 @@ var swagger_default = {
             }
           }
         }
+      },
+      ToolDefinition: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: ["function"] },
+          function: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              description: { type: "string" },
+              parameters: { type: "object" }
+            },
+            required: ["name", "parameters"]
+          }
+        },
+        required: ["type", "function"]
+      },
+      ToolCall: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          type: { type: "string", enum: ["function"] },
+          function: {
+            type: "object",
+            properties: { name: { type: "string" }, arguments: { type: "string" } }
+          }
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-ai-api",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "main": "dist/server/index.js",
   "dependencies": {},
   "peerDependencies": {
@@ -28,5 +28,6 @@
     "client.d.ts",
     "client-v2.d.ts",
     "server.d.ts"
-  ]
+  ],
+  "license": "Apache-2.0"
 }

package/src/server/__tests__/openai-format.test.ts

@@ -0,0 +1,52 @@
+import { toOpenAIResponse, toOpenAIStreamChunk } from '../utils/openai-format';
+import { isStreamingRequested } from '../utils/streaming';
+
+describe('AI API OpenAI tool-call formatting', () => {
+  it('streams by default and only disables streaming for an explicit false value', () => {
+    expect(isStreamingRequested(undefined)).toBe(true);
+    expect(isStreamingRequested(true)).toBe(true);
+    expect(isStreamingRequested(false)).toBe(false);
+  });
+  it('returns tool calls and the matching finish reason for a non-stream response', () => {
+    const response = toOpenAIResponse({
+      id: 'chatcmpl-1',
+      model: 'service/model',
+      content: '',
+      toolCalls: [
+        {
+          id: 'call-1',
+          type: 'function',
+          function: { name: 'get_weather', arguments: '{"city":"Hanoi"}' },
+        },
+      ],
+    });
+
+    expect(response.choices[0].finish_reason).toBe('tool_calls');
+    expect(response.choices[0].message.tool_calls).toEqual([
+      {
+        id: 'call-1',
+        type: 'function',
+        function: { name: 'get_weather', arguments: '{"city":"Hanoi"}' },
+      },
+    ]);
+  });
+
+  it('formats streaming tool-call deltas', () => {
+    const chunk = toOpenAIStreamChunk({
+      id: 'chatcmpl-1',
+      model: 'service/model',
+      delta: {
+        tool_calls: [
+          {
+            index: 0,
+            id: 'call-1',
+            type: 'function',
+            function: { name: 'get_weather', arguments: '{"city"' },
+          },
+        ],
+      },
+    });
+
+    expect(chunk.choices[0].delta.tool_calls?.[0].function?.name).toBe('get_weather');
+  });
+});

package/src/server/routes/agent-completions.ts

@@ -14,9 +14,11 @@ import {
   toOpenAIError,
   formatSSE,
   formatSSEDone,
+  OpenAIToolCallChunk,
 } from '../utils/openai-format';
 import { resolveModelString } from '../utils/resolve-service';
 import { checkEmployeeAccess } from '../middleware/role-permission';
+import { isStreamingRequested } from '../utils/streaming';
 import {
   AgentRuntimeContext,
   createAIEmployeeOptions,
@@ -132,7 +134,7 @@ export async function handleAgentCompletions(ctx: Context, plugin: PluginAiApiSe
     return;
   }
 
-  const wantStream = body.stream === true;
+  const wantStream = isStreamingRequested(body.stream);
   const lifecycle = getAgentRuntimeLifecycle(ctx);
   let runtimeContext: AgentRuntimeContext | undefined;
   let lifecycleCompleted = false;
@@ -256,6 +258,17 @@ export async function handleAgentCompletions(ctx: Context, plugin: PluginAiApiSe
 
       const originalWrite = ctx.res.write.bind(ctx.res);
       const originalEnd = ctx.res.end.bind(ctx.res);
+      const aiPlugin = ctx.app.pm.get('ai') as any;
+      const abortAgent = () => {
+        if (!ctx.res.writableEnded) {
+          aiPlugin?.aiEmployeesManager?.conversationController?.get(String(sessionId))?.abort();
+        }
+      };
+      ctx.req.once('aborted', abortAgent);
+      ctx.res.once('close', abortAgent);
+      let streamSucceeded = false;
+      let sawToolCalls = false;
+      let pendingSse = '';
 
       // Intercept end() — prevent AIEmployee from terminating the stream early.
       // We restore and call it ourselves in the finally block.
@@ -269,46 +282,78 @@ export async function handleAgentCompletions(ctx: Context, plugin: PluginAiApiSe
 
       // Intercept write() — translate NocoBase SSE → OpenAI SSE
       (ctx.res as any).write = (data: Buffer | string): boolean => {
-        const text = typeof data === 'string' ? data : data.toString('utf8');
-
-        for (const line of text.split('\n')) {
-          const trimmed = line.trim();
-          if (!trimmed.startsWith('data: ')) continue;
-
-          const jsonStr = trimmed.substring(6);
-          if (!jsonStr) continue;
-
-          try {
-            const event = JSON.parse(jsonStr);
-
-            if (event.type === 'content' && event.body) {
-              // Content chunk — forward as OpenAI delta
-              originalWrite(
-                formatSSE(
-                  toOpenAIStreamChunk({
-                    id: completionId,
-                    model: body.model,
-                    delta: { content: String(event.body) },
+        pendingSse += typeof data === 'string' ? data : data.toString('utf8');
+        const frames = pendingSse.split('\n\n');
+        pendingSse = frames.pop() || '';
+
+        for (const frame of frames) {
+          for (const line of frame.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data: ')) continue;
+
+            const jsonStr = trimmed.substring(6);
+            if (!jsonStr) continue;
+
+            try {
+              const event = JSON.parse(jsonStr);
+
+              if (event.type === 'content' && event.body) {
+                // Content chunk — forward as OpenAI delta
+                originalWrite(
+                  formatSSE(
+                    toOpenAIStreamChunk({
+                      id: completionId,
+                      model: body.model,
+                      delta: { content: String(event.body) },
+                    }),
+                  ),
+                );
+              } else if (event.type === 'tool_call_chunks' && Array.isArray(event.body)) {
+                const chunks = toOpenAIToolCallChunks(event.body);
+                if (chunks.length) {
+                  sawToolCalls = true;
+                  originalWrite(
+                    formatSSE(
+                      toOpenAIStreamChunk({
+                        id: completionId,
+                        model: body.model,
+                        delta: { tool_calls: chunks },
+                      }),
+                    ),
+                  );
+                }
+              } else if (!sawToolCalls && event.type === 'tool_calls' && Array.isArray(event.body?.toolCalls)) {
+                const chunks = toOpenAIToolCallChunks(event.body.toolCalls);
+                if (chunks.length) {
+                  sawToolCalls = true;
+                  originalWrite(
+                    formatSSE(
+                      toOpenAIStreamChunk({
+                        id: completionId,
+                        model: body.model,
+                        delta: { tool_calls: chunks },
+                      }),
+                    ),
+                  );
+                }
+              } else if (event.type === 'error' && event.body) {
+                // Error from the agent — surface as SSE error object
+                originalWrite(
+                  formatSSE({
+                    error: {
+                      message: String(event.body),
+                      type: 'server_error',
+                      code: 'agent_error',
+                    },
                   }),
-                ),
-              );
-            } else if (event.type === 'error' && event.body) {
-              // Error from the agent — surface as SSE error object
-              originalWrite(
-                formatSSE({
-                  error: {
-                    message: String(event.body),
-                    type: 'server_error',
-                    code: 'agent_error',
-                  },
-                }),
-              );
+                );
+              }
+              // stream_start, stream_end, tool_call_status, web_search,
+              // reasoning and new_message are NocoBase-only events and are ignored.
+              // These are NocoBase-internal events not part of the OpenAI protocol.
+            } catch {
+              // Non-JSON SSE line — ignore
             }
-            // stream_start, stream_end, tool_calls, tool_call_status,
-            // web_search, reasoning, new_message, tool_call_chunks → silently ignored.
-            // These are NocoBase-internal events not part of the OpenAI protocol.
-          } catch {
-            // Non-JSON SSE line — ignore
           }
         }
         return true;
@@ -322,7 +367,10 @@ export async function handleAgentCompletions(ctx: Context, plugin: PluginAiApiSe
           }),
         );
 
-        await aiEmployee.stream({ userMessages });
+        streamSucceeded = await aiEmployee.stream({ userMessages });
+        if (!streamSucceeded) {
+          throw new Error('AI Employee stream failed');
+        }
         try {
           await lifecycle?.runAfterHooks(runtimeContext, { succeeded: true });
         } finally {
@@ -332,20 +380,26 @@ export async function handleAgentCompletions(ctx: Context, plugin: PluginAiApiSe
         // Restore original write/end before sending our closing frames
         (ctx.res as any).write = originalWrite;
         (ctx.res as any).end = originalEnd;
-
-        // Send the finish chunk and [DONE] signal
-        originalWrite(
-          formatSSE(
-            toOpenAIStreamChunk({
-              id: completionId,
-              model: body.model,
-              delta: {},
-              finishReason: 'stop',
-            }),
-          ),
-        );
-        originalWrite(formatSSEDone());
-        originalEnd();
+        ctx.req.off('aborted', abortAgent);
+        ctx.res.off('close', abortAgent);
+
+        if (streamSucceeded && !ctx.res.destroyed) {
+          originalWrite(
+            formatSSE(
+              toOpenAIStreamChunk({
+                id: completionId,
+                model: body.model,
+                delta: {},
+                finishReason: 'stop',
+              }),
+            ),
+          );
+          originalWrite(formatSSEDone());
+          ctx.state.aiApiStreamResult = { succeeded: true, id: completionId };
+        } else {
+          ctx.state.aiApiStreamResult = { succeeded: false, id: completionId, errorCode: 'agent_error' };
+        }
+        if (!ctx.res.writableEnded && !ctx.res.destroyed) originalEnd();
       }
     } else {
       // ── NON-STREAMING (invoke) ─────────────────────────────────────────────
@@ -422,6 +476,19 @@ export async function handleAgentCompletions(ctx: Context, plugin: PluginAiApiSe
   }
 }
 
+function toOpenAIToolCallChunks(value: unknown[]): OpenAIToolCallChunk[] {
+  return value.map((call: any, fallbackIndex) => ({
+    index: typeof call.index === 'number' ? call.index : fallbackIndex,
+    ...(call.id ? { id: String(call.id), type: 'function' as const } : {}),
+    function: {
+      ...(call.name ? { name: String(call.name) } : {}),
+      ...(call.args !== undefined
+        ? { arguments: typeof call.args === 'string' ? call.args : JSON.stringify(call.args) }
+        : {}),
+    },
+  }));
+}
+
 /**
  * Extract the last AI message content from a LangGraph invoke() result.
  *