@jskit-ai/assistant-core 0.1.171 → 0.1.173

package/src/client/conversation/useAssistantSuggestions.js

@@ -0,0 +1,99 @@
+import { computed, onScopeDispose, ref, toValue, unref, watch } from "vue";
+
+/** Suggestion requests use an application-supplied agent; credentials stay on its server. */
+export function useAssistantSuggestions({
+  active = true, requestKey = "", draft = "", configuration = {},
+  generate, onSelect = () => false, debounceMs = 750
+} = {}) {
+  const items = ref([]);
+  const loading = ref(false);
+  const preview = ref("");
+  const error = ref("");
+  const dismissedKey = ref(null);
+  const composerFocused = ref(false);
+  const currentDraft = computed(() => String(toValue(draft) ?? "").trim());
+  const configurationKey = computed(() => JSON.stringify(toValue(configuration) ?? {}));
+  const key = computed(() => JSON.stringify([toValue(requestKey), currentDraft.value, configurationKey.value]));
+  const eligible = computed(() => toValue(active) !== false && typeof unref(generate) === "function" && dismissedKey.value !== key.value);
+  const visible = computed(() => eligible.value && (loading.value || items.value.length > 0));
+  let timer;
+  let request;
+
+  function cancel() {
+    clearTimeout(timer);
+    const previous = request;
+    request = null;
+    previous?.abort();
+    loading.value = false;
+  }
+
+  watch([eligible, key, () => unref(generate)], () => {
+    cancel();
+    items.value = [];
+    preview.value = "";
+    error.value = "";
+    if (!eligible.value) return;
+    const controller = new AbortController();
+    request = controller;
+    const input = {
+      draft: currentDraft.value,
+      configuration: JSON.parse(configurationKey.value),
+      signal: controller.signal
+    };
+    const run = unref(generate);
+    loading.value = true;
+    timer = setTimeout(async () => {
+      try {
+        const result = await run(input);
+        if (request !== controller) return;
+        if (!Array.isArray(result) || result.some(item => !item?.label?.trim() || !item?.prompt?.trim())) {
+          throw new TypeError("Suggestions must contain a label and prompt.");
+        }
+        items.value = result.map(({ label, prompt }) => ({ label: label.trim(), prompt: prompt.trim() }));
+      } catch (failure) {
+        if (request === controller && !controller.signal.aborted) error.value = String(failure.message || failure);
+      } finally {
+        if (request === controller) {
+          request = null;
+          loading.value = false;
+        }
+      }
+    }, Math.max(0, Number(toValue(debounceMs)) || 0));
+  }, { immediate: true, flush: "sync" });
+
+  function currentSuggestion(value) {
+    return items.value.find(item => item.label === value?.label && item.prompt === value?.prompt);
+  }
+  function previewSuggestion(value) {
+    preview.value = currentDraft.value ? "" : currentSuggestion(value)?.prompt || "";
+    return Boolean(preview.value);
+  }
+  function select(value) {
+    const suggestion = currentSuggestion(value);
+    if (!suggestion || !eligible.value) return false;
+    preview.value = "";
+    return onSelect(suggestion.prompt) !== false;
+  }
+  function dismiss() {
+    preview.value = "";
+    dismissedKey.value = key.value;
+  }
+  function focus() {
+    if (toValue(active) === false || composerFocused.value) return;
+    dismissedKey.value = null;
+    composerFocused.value = true;
+  }
+  function blur() {
+    preview.value = "";
+    composerFocused.value = false;
+  }
+  watch(() => toValue(active), value => {
+    if (value === false) {
+      composerFocused.value = false;
+      dismissedKey.value = null;
+    }
+  }, { flush: "sync" });
+  watch(currentDraft, () => { preview.value = ""; }, { flush: "sync" });
+  onScopeDispose(cancel);
+  return { items, loading, preview, error, visible, composerFocused, previewSuggestion, select, dismiss, focus, blur };
+}

package/src/server/index.js

@@ -1,4 +1,5 @@
 export { createAiClient, SUPPORTED_AI_PROVIDERS, DEFAULT_AI_PROVIDER } from "./lib/aiClient.js";
+export { createAiConnectionClient } from "./lib/aiConnectionClient.js";
 export {
   DEFAULT_AI_TIMEOUT_MS,
   normalizeOptionalHttpUrl,

package/src/server/lib/aiConnectionClient.js

@@ -0,0 +1,90 @@
+import { generateText, jsonSchema, streamText } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogle } from "@ai-sdk/google";
+import { createGroq } from "@ai-sdk/groq";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { createCerebras } from "@ai-sdk/cerebras";
+import { createMistral } from "@ai-sdk/mistral";
+import { createPerplexity } from "@ai-sdk/perplexity";
+import { createTogetherAI } from "@ai-sdk/togetherai";
+import { createXai } from "@ai-sdk/xai";
+
+// These adapters are installed with the package. The catalogue selects a
+// protocol; it cannot cause dynamic imports or dependency installation.
+const providers = {
+  "@ai-sdk/openai": createOpenAI,
+  "@ai-sdk/openai-compatible": createOpenAICompatible,
+  "@ai-sdk/anthropic": createAnthropic,
+  "@ai-sdk/google": createGoogle,
+  "@ai-sdk/groq": createGroq,
+  "@openrouter/ai-sdk-provider": createOpenRouter,
+  "@ai-sdk/cerebras": createCerebras,
+  "@ai-sdk/mistral": createMistral,
+  "@ai-sdk/perplexity": createPerplexity,
+  "@ai-sdk/togetherai": createTogetherAI,
+  "@ai-sdk/xai": createXai
+};
+
+function sdkMessages(messages) {
+  const toolNames = new Map();
+  return messages.map(message => {
+    if (message.role === "assistant" && message.tool_calls?.length) {
+      const content = message.content ? [{ type: "text", text: message.content }] : [];
+      for (const call of message.tool_calls) {
+        toolNames.set(call.id, call.function.name);
+        content.push({ type: "tool-call", toolCallId: call.id, toolName: call.function.name, input: JSON.parse(call.function.arguments) });
+      }
+      return { role: "assistant", content };
+    }
+    if (message.role === "tool") {
+      return { role: "tool", content: [{ type: "tool-result", toolCallId: message.tool_call_id,
+        toolName: toolNames.get(message.tool_call_id), output: { type: "text", value: message.content } }] };
+    }
+    return { role: message.role, content: message.content };
+  });
+}
+
+/** Accept only the server-side result of an authorized AI connection resolver. */
+export function createAiConnectionClient(connection, { fetch, timeoutMs = 120_000, maxOutputTokens } = {}) {
+  if (!connection?.apiKey || !connection.model || !Object.hasOwn(providers, connection.sdkPackage)) {
+    throw new TypeError("An authorized AI connection with a supported SDK and model is required.");
+  }
+  const provider = providers[connection.sdkPackage]({
+    name: connection.providerId, apiKey: connection.apiKey, baseURL: connection.baseURL, fetch
+  });
+  const model = provider(connection.model);
+  function options({ messages = [], tools = [], signal, temperature } = {}) {
+    return {
+      model, messages: sdkMessages(messages), allowSystemInMessages: true,
+      tools: Object.fromEntries(tools.map(({ function: tool }) => [tool.name, {
+        description: tool.description, inputSchema: jsonSchema(tool.parameters)
+      }])),
+      abortSignal: signal, timeout: timeoutMs, maxRetries: 0, temperature, maxOutputTokens
+    };
+  }
+  return Object.freeze({
+    enabled: true, supportsAttachments: true, provider: connection.providerId, defaultModel: connection.model,
+    async createChatCompletion(input) {
+      const result = await generateText(options(input));
+      return { choices: [{ message: { role: "assistant", content: result.text,
+        tool_calls: result.toolCalls.map(call => ({ id: call.toolCallId, type: "function",
+          function: { name: call.toolName, arguments: JSON.stringify(call.input) } })) } }] };
+    },
+    async *createChatCompletionStream(input) {
+      const result = streamText({ ...options(input), onError() {} });
+      let toolIndex = 0;
+      for await (const part of result.fullStream) {
+        if (part.type === "error") throw part.error;
+        if (part.type === "abort") throw input?.signal?.reason || new Error("Assistant request was aborted.");
+        if (part.type === "text-delta") yield { choices: [{ delta: { content: part.text } }] };
+        if (part.type === "tool-call") {
+          if (part.invalid) throw part.error;
+          yield { choices: [{ delta: { tool_calls: [{ index: toolIndex++, id: part.toolCallId,
+            function: { name: part.toolName, arguments: JSON.stringify(part.input) } }] } }] };
+        }
+      }
+    }
+  });
+}

package/src/server/lib/providers/anthropicClient.js

@@ -1,3 +1,4 @@
+import { createAiConnectionClient } from "../aiConnectionClient.js";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import {
   createDisabledClient,
@@ -201,12 +202,6 @@ function mapAnthropicContentToOpenAiDelta(content = []) {
   return delta;
 }
 
-function createSingleChunkStream(chunk) {
-  return (async function* singleChunkGenerator() {
-    yield chunk;
-  })();
-}
-
 async function fetchAnthropicMessage({
   apiKey,
   baseUrl,
@@ -349,21 +344,11 @@ function createAnthropicClient({
     provider: "anthropic",
     defaultModel: normalizedModel,
     createChatCompletion: createCompletion,
-    async createChatCompletionStream({ messages = [], tools = [], temperature = 0.2, signal } = {}) {
-      const completion = await createCompletion({
-        messages,
-        tools,
-        temperature,
-        signal
-      });
-
-      return createSingleChunkStream({
-        choices: [
-          {
-            delta: completion.__openAiLikeDelta || {}
-          }
-        ]
-      });
+    createChatCompletionStream(input) {
+      return createAiConnectionClient({
+        providerId: "anthropic", sdkPackage: "@ai-sdk/anthropic", apiKey: normalizedApiKey,
+        model: normalizedModel, baseURL: `${normalizedBaseUrl}/v1`
+      }, { timeoutMs, maxOutputTokens: DEFAULT_ANTHROPIC_MAX_OUTPUT_LIMIT }).createChatCompletionStream({ temperature: 0.2, ...input });
     }
   });
 }

package/src/shared/assistantResource.js

@@ -10,7 +10,12 @@ const MAX_HISTORY_MESSAGES = 20;
 const MAX_PAGE_SIZE = 200;
 const MAX_MESSAGE_PAGE_SIZE = 500;
 
+const attachmentIdsField = {
+  type: "array", required: false, maxItems: 10,
+  items: { type: "string", minLength: 1, maxLength: 256 }
+};
 const historyMessageSchema = createSchema({
+  attachmentIds: attachmentIdsField,
   role: {
     type: "string",
     required: true,
@@ -38,6 +43,8 @@ const clientContextSchema = createSchema({
 });
 
 const chatStreamBodySchema = createSchema({
+  attachmentIds: attachmentIdsField,
+  integrationId: { type: "string", required: false, minLength: 1, maxLength: 128 },
   messageId: {
     type: "string",
     required: true,

package/src/shared/conversation/attachments.js

@@ -0,0 +1,13 @@
+export function attachmentSizeLabel(size) {
+  const bytes = Number(size);
+  if (!Number.isFinite(bytes) || bytes < 0) {
+    return "";
+  }
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/src/shared/conversation/index.js

@@ -4,3 +4,4 @@ export * from "./numberedQuestionSugar.js";
 export * from "./answerChoiceSugar.js";
 export * from "./thinkingText.js";
 export * from "./scrollFollowState.js";
+export * from "./attachments.js";

package/test/aiConnectionClient.test.js

@@ -0,0 +1,159 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createAiConnectionResolver } from "../../connectors-catalog/src/server/ai.js";
+import { createAiConnectionClient } from "../src/server/lib/aiConnectionClient.js";
+import { createAiClient } from "../src/server/lib/aiClient.js";
+
+function publicConnection(model = "opencode/big-pickle") {
+  return createAiConnectionResolver({
+    configuration: { schemaVersion: 1, registrations: {}, integrations: {
+      assistant: { provider: "ai", accountMode: "shared", scopes: [], authentication: { method: "none" }, settings: { model } }
+    } },
+    authorize: () => ({ applicationId: "example", subjectId: "user" })
+  }).resolve({ context: {}, integrationId: "assistant" });
+}
+
+function eventsResponse(events) {
+  return new Response(events.map(data => `data: ${JSON.stringify(data)}\n\n`).join(""), {
+    headers: { "content-type": "text/event-stream" }
+  });
+}
+
+test("the configured public AI integration streams its first chunk before completion", async () => {
+  const connection = await publicConnection();
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  const client = createAiConnectionClient(connection, {
+    async fetch(url, options) {
+      assert.equal(String(url), "https://opencode.ai/zen/v1/chat/completions");
+      assert.equal(new Headers(options.headers).get("authorization"), "Bearer public");
+      const body = JSON.parse(options.body);
+      assert.equal(body.model, "big-pickle");
+      assert.equal(body.stream, true);
+      return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+    }
+  });
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Hello" }] });
+  const first = iterator.next();
+  await writer.write(new TextEncoder().encode('data: {"choices":[{"index":0,"delta":{"content":"Hello"}}]}\n\n'));
+  assert.equal((await first).value.choices[0].delta.content, "Hello");
+  const second = iterator.next();
+  await writer.write(new TextEncoder().encode('data: {"choices":[{"index":0,"delta":{"content":" there"}}]}\n\n'));
+  assert.equal((await second).value.choices[0].delta.content, " there");
+  await writer.write(new TextEncoder().encode('data: {"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n'));
+  await writer.close();
+  assert.equal((await iterator.next()).done, true);
+});
+
+test("tools remain application executed and their results return through the same SDK protocol", async () => {
+  let round = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch(_url, options) {
+      const body = JSON.parse(options.body);
+      assert.equal(body.tools[0].function.name, "lookup");
+      if (++round === 1) return eventsResponse([{ choices: [{ index: 0, delta: { tool_calls: [
+        { index: 0, id: "call_1", type: "function", function: { name: "lookup", arguments: '{"query":"records"}' } }
+      ] }, finish_reason: "tool_calls" }] }]);
+      assert.equal(body.messages.at(-1).role, "tool");
+      assert.equal(body.messages.at(-1).tool_call_id, "call_1");
+      assert.equal(body.messages.at(-1).content, "Three records.");
+      return eventsResponse([{ choices: [{ index: 0, delta: { content: "There are three records." }, finish_reason: "stop" }] }]);
+    }
+  });
+  const tools = [{ type: "function", function: { name: "lookup", parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] } } }];
+  const messages = [{ role: "system", content: "Use the available actions." }, { role: "user", content: "Find records" }];
+  const first = await Array.fromAsync(client.createChatCompletionStream({ messages, tools }));
+  const call = first[0].choices[0].delta.tool_calls[0];
+  assert.deepEqual(call.function, { name: "lookup", arguments: '{"query":"records"}' });
+  assert.equal(round, 1, "The SDK must not start another tool round on its own");
+  const result = await Array.fromAsync(client.createChatCompletionStream({ tools, messages: [
+    ...messages, { role: "assistant", content: "", tool_calls: [{ ...call, type: "function" }] },
+    { role: "tool", tool_call_id: call.id, content: "Three records." }
+  ] }));
+  assert.equal(result[0].choices[0].delta.content, "There are three records.");
+});
+
+test("the integration preserves the OpenAI Responses route for Zen Muse models", async () => {
+  const client = createAiConnectionClient(await publicConnection("opencode/muse-spark-1.3-contributor-free"), {
+    async fetch(url, options) {
+      assert.equal(String(url), "https://opencode.ai/zen/v1/responses");
+      assert.equal(JSON.parse(options.body).model, "muse-spark-1.3-contributor-free");
+      return eventsResponse([
+        { type: "response.output_item.added", output_index: 0, item: { type: "message", id: "item_1", role: "assistant", content: [], status: "in_progress" } },
+        { type: "response.output_text.delta", item_id: "item_1", output_index: 0, content_index: 0, delta: "Live response" },
+        { type: "response.completed", response: { id: "resp_1", created_at: 1, model: "muse-spark-1.3-contributor-free", status: "completed", output: [], usage: { input_tokens: 1, output_tokens: 2, total_tokens: 3 } } }
+      ]);
+    }
+  });
+  const chunks = await Array.fromAsync(client.createChatCompletionStream({ messages: [{ role: "user", content: "Hi" }] }));
+  assert.equal(chunks[0].choices[0].delta.content, "Live response");
+});
+
+test("provider failures propagate without retries or fallback models", async () => {
+  let requests = 0;
+  const client = createAiConnectionClient(await publicConnection(), {
+    fetch() { requests++; return new Response('{"error":{"message":"Capacity unavailable"}}', { status: 429 }); }
+  });
+  await assert.rejects(Array.fromAsync(client.createChatCompletionStream({ messages: [{ role: "user", content: "Hi" }] })), /Capacity unavailable/u);
+  assert.equal(requests, 1);
+});
+
+test("legacy Anthropic configuration streams through the native Messages protocol", async t => {
+  const source = new TransformStream();
+  const writer = source.writable.getWriter();
+  t.mock.method(globalThis, "fetch", async (url, options) => {
+    assert.equal(String(url), "https://anthropic.example/v1/messages");
+    assert.equal(JSON.parse(options.body).max_tokens, 4096);
+    assert.equal(new Headers(options.headers).get("x-api-key"), "test-key");
+    assert.equal(JSON.parse(options.body).stream, true);
+    return new Response(source.readable, { headers: { "content-type": "text/event-stream" } });
+  });
+  const client = createAiClient({ provider: "anthropic", apiKey: "test-key", baseUrl: "https://anthropic.example", model: "claude-test" });
+  const iterator = client.createChatCompletionStream({ messages: [{ role: "user", content: "Hi" }] });
+  const first = iterator.next();
+  const send = data => writer.write(new TextEncoder().encode(`event: ${data.type}\ndata: ${JSON.stringify(data)}\n\n`));
+  await send({ type: "message_start", message: { id: "msg_1", type: "message", role: "assistant", content: [], model: "claude-test", stop_reason: null, stop_sequence: null, usage: { input_tokens: 1, output_tokens: 0 } } });
+  await send({ type: "content_block_start", index: 0, content_block: { type: "text", text: "" } });
+  await send({ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Streaming now" } });
+  assert.equal((await first).value.choices[0].delta.content, "Streaming now");
+  await send({ type: "content_block_stop", index: 0 });
+  await send({ type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: 2 } });
+  await send({ type: "message_stop" });
+  await writer.close();
+  assert.equal((await iterator.next()).done, true);
+});
+
+test("Google connections use streaming generateContent and preserve cancellation", async () => {
+  const abort = new AbortController();
+  const requestStarted = Promise.withResolvers();
+  const client = createAiConnectionClient({ providerId: "google", sdkPackage: "@ai-sdk/google", apiKey: "test-key", model: "gemini-test" }, {
+    fetch(url, options) {
+      assert.match(String(url), /models\/gemini-test:streamGenerateContent/u);
+      assert.equal(new Headers(options.headers).get("x-goog-api-key"), "test-key");
+      assert.equal(JSON.parse(options.body).contents[0].parts[0].text, "Hi");
+      requestStarted.resolve();
+      return new Promise((_resolve, reject) => options.signal.addEventListener("abort", () => reject(options.signal.reason), { once: true }));
+    }
+  });
+  const result = Array.fromAsync(client.createChatCompletionStream({ messages: [{ role: "user", content: "Hi" }], signal: abort.signal }));
+  await requestStarted.promise;
+  abort.abort(new Error("Stopped by the user"));
+  await assert.rejects(result, /Stopped by the user/u);
+});
+
+
+test("authorized image bytes use the selected provider protocol", async () => {
+  const client = createAiConnectionClient(await publicConnection(), {
+    async fetch(_url, options) {
+      const content = JSON.parse(options.body).messages[0].content;
+      assert.equal(content[0].text, "Describe this");
+      assert.equal(content[1].type, "image_url");
+      assert.equal(content[1].image_url.url, "data:image/png;base64,AQID");
+      return eventsResponse([{ choices: [{ index: 0, delta: { content: "An image" }, finish_reason: "stop" }] }]);
+    }
+  });
+  const chunks = await Array.fromAsync(client.createChatCompletionStream({ messages: [{ role: "user", content: [
+    { type: "text", text: "Describe this" }, { type: "image", image: new Uint8Array([1, 2, 3]), mediaType: "image/png" }
+  ] }] }));
+  assert.equal(chunks[0].choices[0].delta.content, "An image");
+});