libfx 0.0.7 → 0.0.8-dev.857.gba60fd94fa57

package/skills.js

@@ -0,0 +1,44 @@
+const maxSkills = 64;
+const maxInstructionsBytes = 64 * 1024;
+
+function escapeAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;");
+}
+
+export function createSkillsAdapter(records) {
+  if (!Array.isArray(records) || records.length > maxSkills) {
+    throw new TypeError("skills must be an array with at most 64 records");
+  }
+  const names = new Set();
+  const sections = [];
+  const tools = [];
+  for (const [index, record] of records.entries()) {
+    if (!record || typeof record.name !== "string" || typeof record.instructions !== "string") {
+      throw new TypeError(`skill ${index} requires name and instructions`);
+    }
+    if (names.has(record.name)) throw new TypeError(`duplicate skill name: ${record.name}`);
+    names.add(record.name);
+    const resources = (record.resources ?? []).map((resource) => {
+      if (typeof resource?.uri !== "string" || typeof resource?.text !== "string") {
+        throw new TypeError(`skill ${record.name} has an invalid resource`);
+      }
+      return `<resource uri="${escapeAttribute(resource.uri)}">\n${resource.text}\n</resource>`;
+    }).join("\n");
+    sections.push([
+      `<skill name="${escapeAttribute(record.name)}">`,
+      record.description ? `<description>${record.description}</description>` : "",
+      record.instructions,
+      resources,
+      "</skill>",
+    ].filter(Boolean).join("\n"));
+    if (record.tools !== undefined) {
+      if (!Array.isArray(record.tools)) throw new TypeError(`skill ${record.name} tools must be an array`);
+      tools.push(...record.tools);
+    }
+  }
+  const instructions = sections.join("\n\n");
+  if (new TextEncoder().encode(instructions).length > maxInstructionsBytes) {
+    throw new RangeError(`skill instructions exceed the ${maxInstructionsBytes} byte libfx limit`);
+  }
+  return { instructions, tools };
+}

package/wasm-module.js

@@ -0,0 +1,50 @@
+const modulePromisesBySource = new Map();
+const modulePromisesByObject = new WeakMap();
+const moduleFailureSource = Symbol("libfx.moduleFailureSource");
+
+export function withModuleFailure(input, onFailure) {
+  return { [moduleFailureSource]: { input, onFailure } };
+}
+
+async function compileModule(input) {
+  const failureSource = input?.[moduleFailureSource];
+  if (failureSource) {
+    try {
+      return await compileModule(failureSource.input);
+    } catch (error) {
+      failureSource.onFailure();
+      throw error;
+    }
+  }
+  if (input instanceof WebAssembly.Module) return input;
+  if (typeof input === "string") input = fetch(input);
+  if (input instanceof Promise) input = await input;
+  if (input instanceof WebAssembly.Module) return input;
+  if (input instanceof Response) {
+    const contentType = input.headers.get("content-type")?.split(";", 1)[0].trim().toLowerCase();
+    if (contentType === "application/wasm" && typeof WebAssembly.compileStreaming === "function") {
+      return WebAssembly.compileStreaming(input);
+    }
+    const bytes = await input.arrayBuffer();
+    return WebAssembly.compile(bytes);
+  }
+  if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) {
+    return WebAssembly.compile(input);
+  }
+  throw new TypeError("wasm must be a URL, Response, ArrayBuffer, typed array, or WebAssembly.Module");
+}
+
+export function loadModule(input) {
+  if (input instanceof WebAssembly.Module) return Promise.resolve(input);
+  const isString = typeof input === "string";
+  if (!isString && (typeof input !== "object" || input === null)) return compileModule(input);
+  const cache = isString ? modulePromisesBySource : modulePromisesByObject;
+  const cached = cache.get(input);
+  if (cached) return cached;
+  const pending = compileModule(input);
+  cache.set(input, pending);
+  pending.catch(() => {
+    if (cache.get(input) === pending) cache.delete(input);
+  });
+  return pending;
+}