@miraiclip/assistant 0.1.0

package/dist/index.js

@@ -0,0 +1,774 @@
+// src/types.ts
+var ChatModelError = class extends Error {
+  constructor(provider, message, status) {
+    super(`${provider}: ${message}`);
+    this.provider = provider;
+    this.status = status;
+    this.name = "ChatModelError";
+  }
+  provider;
+  status;
+};
+function defaultFetch() {
+  if (typeof fetch !== "function") throw new Error("No global fetch: pass `fetch` explicitly");
+  return (url, init) => fetch(url, init);
+}
+function defineChatModel(model) {
+  if (!model.id || !/^[a-z0-9][a-z0-9_-]*$/i.test(model.id)) {
+    throw new Error(`Chat model id must be alphanumeric with - or _ (got "${model.id}")`);
+  }
+  if (typeof model.complete !== "function") throw new Error(`Chat model "${model.id}" has no complete()`);
+  return model;
+}
+
+// src/openai.ts
+function toOpenAIMessages(messages) {
+  return messages.map((m) => {
+    if (m.role === "assistant") {
+      const out = { role: "assistant", content: m.content || null };
+      if (m.toolCalls?.length) {
+        out.tool_calls = m.toolCalls.map((c) => ({ id: c.id, type: "function", function: { name: c.name, arguments: JSON.stringify(c.arguments) } }));
+      }
+      return out;
+    }
+    if (m.role === "tool") return { role: "tool", tool_call_id: m.toolCallId, content: m.content };
+    return { role: m.role, content: m.content };
+  });
+}
+function parseToolArguments(raw) {
+  if (!raw.trim()) return {};
+  try {
+    const value = JSON.parse(raw);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : { __invalidArguments: raw };
+  } catch {
+    return { __invalidArguments: raw };
+  }
+}
+var FINISH = {
+  stop: "stop",
+  tool_calls: "tool_calls",
+  function_call: "tool_calls",
+  length: "length",
+  content_filter: "content_filter"
+};
+function openAIChatModel(options) {
+  const base = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+  const id = options.id ?? "openai";
+  const doFetch = options.fetch ?? defaultFetch();
+  const stream = options.stream ?? true;
+  const models = [{ id: options.model }, ...(options.models ?? []).filter((m) => m.id !== options.model)];
+  return defineChatModel({
+    id,
+    label: options.label ?? "OpenAI",
+    models,
+    async complete(request, opts = {}) {
+      const body = {
+        model: request.model ?? options.model,
+        messages: toOpenAIMessages(request.messages),
+        ...request.tools?.length ? { tools: request.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.inputSchema } })) } : {},
+        ...request.maxOutputTokens ? { max_completion_tokens: request.maxOutputTokens } : {},
+        ...stream ? { stream: true, stream_options: { include_usage: true } } : {},
+        ...options.params,
+        ...request.params
+      };
+      const headers = { "Content-Type": "application/json", ...options.headers };
+      if (options.apiKey) headers["Authorization"] = `Bearer ${options.apiKey}`;
+      if (options.organization) headers["OpenAI-Organization"] = options.organization;
+      if (options.project) headers["OpenAI-Project"] = options.project;
+      const res = await doFetch(`${base}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        ...opts.signal ? { signal: opts.signal } : {}
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => null);
+        throw new ChatModelError(id, err?.error?.message ?? `HTTP ${res.status}`, res.status);
+      }
+      if (!stream || !res.body || !(res.headers.get("content-type") ?? "").includes("event-stream")) {
+        return fromCompletion(await res.json(), opts.onText);
+      }
+      return readStream(res.body, opts.onText);
+    }
+  });
+}
+function fromCompletion(json2, onText) {
+  const choice = json2.choices?.[0];
+  const content = choice?.message?.content ?? "";
+  if (content) onText?.(content);
+  const out = {
+    content,
+    toolCalls: (choice?.message?.tool_calls ?? []).map((c) => ({ id: c.id, name: c.function.name, arguments: parseToolArguments(c.function.arguments) })),
+    finish: FINISH[choice?.finish_reason ?? ""] ?? "other"
+  };
+  if (json2.model) out.model = json2.model;
+  if (json2.usage) out.usage = usage(json2.usage);
+  return out;
+}
+var usage = (u) => ({
+  ...u.prompt_tokens !== void 0 ? { inputTokens: u.prompt_tokens } : {},
+  ...u.completion_tokens !== void 0 ? { outputTokens: u.completion_tokens } : {}
+});
+async function readStream(body, onText) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let content = "";
+  let finish = "other";
+  let model;
+  let use;
+  const calls = /* @__PURE__ */ new Map();
+  const handle = (data) => {
+    if (data === "[DONE]") return;
+    let chunk;
+    try {
+      chunk = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (chunk.model) model = chunk.model;
+    if (chunk.usage) use = usage(chunk.usage);
+    for (const choice of chunk.choices ?? []) {
+      const delta = choice.delta;
+      if (delta?.content) {
+        content += delta.content;
+        onText?.(delta.content);
+      }
+      for (const tc of delta?.tool_calls ?? []) {
+        const call = calls.get(tc.index) ?? { id: "", name: "", args: "" };
+        if (tc.id) call.id = tc.id;
+        if (tc.function?.name) call.name += tc.function.name;
+        if (tc.function?.arguments) call.args += tc.function.arguments;
+        calls.set(tc.index, call);
+      }
+      if (choice.finish_reason) finish = FINISH[choice.finish_reason] ?? "other";
+    }
+  };
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (value) buffer += decoder.decode(value, { stream: true });
+    let nl;
+    while ((nl = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, nl).replace(/\r$/, "");
+      buffer = buffer.slice(nl + 1);
+      if (line.startsWith("data:")) handle(line.slice(5).trim());
+    }
+    if (done) break;
+  }
+  if (buffer.startsWith("data:")) handle(buffer.slice(5).trim());
+  const toolCalls = [...calls.entries()].sort(([a], [b]) => a - b).map(([index, c]) => ({ id: c.id || `call_${index}`, name: c.name, arguments: parseToolArguments(c.args) }));
+  const out = { content, toolCalls, finish };
+  if (model) out.model = model;
+  if (use) out.usage = use;
+  return out;
+}
+
+// src/http.ts
+function createChatHandler(model, options = {}) {
+  const base = (options.basePath ?? "").replace(/\/+$/, "");
+  const maxBody = options.maxBodyBytes ?? 2e6;
+  return async function handle(request) {
+    const path = new URL(request.url).pathname;
+    if (base && path !== base && !path.startsWith(`${base}/`)) return null;
+    const rest = path.slice(base.length).replace(/\/+$/, "");
+    const refused = await options.authorize?.(request);
+    if (refused) return refused;
+    if (rest === "" && request.method === "GET") {
+      return json(200, { id: model.id, label: model.label, models: model.models ?? [] });
+    }
+    if (rest !== "/chat" || request.method !== "POST") return json(404, { error: "not found" });
+    const text = await request.text();
+    if (text.length > maxBody) return json(413, { error: "request too large" });
+    let chat;
+    try {
+      chat = JSON.parse(text).request;
+    } catch {
+      return json(400, { error: "body must be JSON { request }" });
+    }
+    if (!chat || !Array.isArray(chat.messages)) return json(400, { error: "request.messages is required" });
+    if (options.prepare) chat = options.prepare(chat);
+    const encoder = new TextEncoder();
+    const body = new ReadableStream({
+      async start(controller) {
+        const send = (value) => controller.enqueue(encoder.encode(`${JSON.stringify(value)}
+`));
+        try {
+          const response = await model.complete(chat, { signal: request.signal, onText: (delta) => send({ type: "text", delta }) });
+          send({ type: "done", response });
+        } catch (err) {
+          const status = err?.status;
+          send({ type: "error", error: err?.message ?? String(err), ...status ? { status } : {} });
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(body, { status: 200, headers: { "content-type": "application/x-ndjson", "cache-control": "no-store" } });
+  };
+}
+var json = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+async function remoteChatModel(endpoint, options = {}) {
+  const doFetch = options.fetch ?? defaultFetch();
+  const root = endpoint.replace(/\/+$/, "");
+  let info = options.info;
+  if (!info) {
+    const res = await doFetch(`${root}/`, { headers: { Accept: "application/json", ...options.headers } });
+    if (!res.ok) throw new ChatModelError("remote", `HTTP ${res.status}`, res.status);
+    info = await res.json();
+  }
+  const { id, label, models } = info;
+  return {
+    id,
+    label,
+    ...models ? { models } : {},
+    async complete(request, opts = {}) {
+      const res = await doFetch(`${root}/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/x-ndjson", ...options.headers },
+        body: JSON.stringify({ request }),
+        ...opts.signal ? { signal: opts.signal } : {}
+      });
+      if (!res.ok || !res.body) {
+        const err = await res.json().catch(() => null);
+        throw new ChatModelError(id, err?.error ?? `HTTP ${res.status}`, res.status);
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let final;
+      const handle = (line) => {
+        if (!line.trim()) return;
+        const event = JSON.parse(line);
+        if (event.type === "text" && event.delta) opts.onText?.(event.delta);
+        else if (event.type === "done") final = event.response;
+        else if (event.type === "error") throw new ChatModelError(id, event.error ?? "failed", event.status);
+      };
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (value) buffer += decoder.decode(value, { stream: true });
+        let nl;
+        while ((nl = buffer.indexOf("\n")) >= 0) {
+          handle(buffer.slice(0, nl));
+          buffer = buffer.slice(nl + 1);
+        }
+        if (done) break;
+      }
+      handle(buffer);
+      if (!final) throw new ChatModelError(id, "the server closed the stream without a response");
+      return final;
+    }
+  };
+}
+
+// src/tools.ts
+import {
+  ANIMATION_EASINGS,
+  ANIMATION_PRESETS,
+  animationCommands,
+  applyCommands,
+  commandCatalog,
+  builtinTransitionParamSchemas,
+  describeAnimation,
+  describeProject,
+  findCuts,
+  fitAnimation,
+  readAnimation,
+  toToolDefinitions
+} from "@miraiclip/core";
+function defineTool(tool) {
+  if (!/^[a-zA-Z0-9_-]{1,64}$/.test(tool.name)) throw new Error(`Tool name must match ^[a-zA-Z0-9_-]{1,64}$ (got "${tool.name}")`);
+  return tool;
+}
+function toolsFromDefinitions(definitions, run, options = {}) {
+  return definitions.map((d) => {
+    const def = d;
+    const name = def.function?.name ?? def.name;
+    return defineTool({
+      name,
+      description: def.function?.description ?? def.description ?? "",
+      inputSchema: def.function?.parameters ?? def.input_schema ?? { type: "object", properties: {} },
+      async run(input, ctx) {
+        const out = await run(name, input, ctx);
+        if (!out.ok) return { ok: false, error: out.error ?? "failed" };
+        const changes = options.changes?.(name, input, out.result);
+        return { ok: true, result: out.result, ...changes?.length ? { changes } : {} };
+      }
+    });
+  });
+}
+var S = 1e6;
+var seconds = (us) => `${Math.round(us / 1e5) / 10}s`;
+var toUs = (s) => typeof s === "number" && Number.isFinite(s) ? Math.round(s * S) : void 0;
+var PHRASES = {
+  "clip/add": (p) => p.kind === "text" ? `Added text "${String(p.text ?? "").slice(0, 40)}" at ${seconds(Number(p.startUs))}` : `Added a ${p.kind} clip at ${seconds(Number(p.startUs))}`,
+  "clip/remove": (p) => `Removed clip ${p.clipId}`,
+  "clip/move": (p) => `Moved clip ${p.clipId}${p.startUs !== void 0 ? ` to ${seconds(Number(p.startUs))}` : ""}`,
+  "clip/trim": (p) => `Trimmed clip ${p.clipId}`,
+  "clip/split": (p) => `Split clip ${p.clipId} at ${seconds(Number(p.atUs))}`,
+  "clip/duplicate": (p) => `Duplicated clip ${p.clipId}`,
+  "clip/set-property": (p) => `Changed ${Object.keys(p).filter((k) => k !== "clipId").join(", ")} of clip ${p.clipId}`,
+  "track/add": (p) => `Added a ${p.kind} track`,
+  "track/remove": (p) => `Removed track ${p.id}`,
+  "track/set-property": (p) => `Changed track ${p.trackId}: ${Object.keys(p).filter((k) => k !== "trackId").join(", ")}`,
+  "effect/add": (p) => `Added ${p.kind} to clip ${p.clipId}`,
+  "effect/update": (p) => `Adjusted an effect on clip ${p.clipId}`,
+  "effect/remove": (p) => `Removed an effect from clip ${p.clipId}`,
+  "transition/add": (p) => `Added a ${p.kind} transition`,
+  "transition/remove": () => "Removed a transition",
+  "project/set-settings": () => "Changed the project settings"
+};
+function describeCommands(commands) {
+  const lines = [];
+  const keyframed = /* @__PURE__ */ new Set();
+  for (const c of commands) {
+    const p = c.payload ?? {};
+    if (c.type.startsWith("keyframe/")) {
+      const id = String(p.clipId);
+      if (!keyframed.has(id)) lines.push(`Changed the animation of clip ${id}`);
+      keyframed.add(id);
+      continue;
+    }
+    const phrase = PHRASES[c.type];
+    lines.push(phrase ? phrase(p) : `${c.type}`);
+  }
+  return lines;
+}
+var US_NOTE = "Times in commands are integer MICROSECONDS (1 s = 1000000).";
+function editorTools(options = {}) {
+  const transitionKinds = options.transitionKinds ?? Object.keys(builtinTransitionParamSchemas);
+  const presetIds = (slot) => ANIMATION_PRESETS.filter((p) => p.slot === slot).map((p) => p.id.split(":")[1]);
+  return [
+    defineTool({
+      name: "get_state",
+      description: `The project as it is now (after your edits so far): settings, assets, tracks with clips (ids, kinds, time ranges), transitions. ${US_NOTE}`,
+      inputSchema: {
+        type: "object",
+        properties: { includeJson: { type: "boolean", description: "Also return the full document JSON (verbose; only for exact field values)." } },
+        additionalProperties: false
+      },
+      run(input, { project }) {
+        const summary = describeProject(project.toJSON());
+        return { ok: true, result: input.includeJson ? { summary, document: project.toJSON() } : summary };
+      }
+    }),
+    defineTool({
+      name: "get_command_schema",
+      description: "The JSON Schema of one editing command's payload. Look it up before using a command in apply_commands for the first time.",
+      inputSchema: {
+        type: "object",
+        properties: { type: { type: "string", description: 'Command type, e.g. "clip/add".' } },
+        required: ["type"],
+        additionalProperties: false
+      },
+      run(input, { project }) {
+        const catalog = project.commandCatalog();
+        const schema = catalog[String(input.type)];
+        return schema ? { ok: true, result: schema } : { ok: false, error: { error: `unknown command "${input.type}"`, validTypes: Object.keys(catalog).sort() } };
+      }
+    }),
+    defineTool({
+      name: "apply_commands",
+      description: `Apply editing commands as one all-or-nothing batch. On failure nothing changes and the error names the failing index and why (invalid payload issues, or the engine's rejection reason) \u2014 fix it and retry. Give new clips, tracks and assets your own readable ids. ${US_NOTE}`,
+      inputSchema: applyCommandsSchema(options.commandCatalog ?? commandCatalog()),
+      run(input, { project }) {
+        const commands = input.commands;
+        if (!Array.isArray(commands) || commands.length === 0) return { ok: false, error: "commands must be a non-empty array of { type, payload }" };
+        const result = applyCommands(project, commands);
+        if (!result.ok) return { ok: false, error: result };
+        return { ok: true, result: { applied: result.applied }, changes: describeCommands(commands) };
+      }
+    }),
+    defineTool({
+      name: "add_transition",
+      description: "Add (or replace, or remove) a transition on cuts \u2014 where one clip ends exactly where the next starts on the same video track. Pick the cut by its two clip ids, by a time near it, or all cuts. A transition overlaps both clips around the cut, so its length is capped by the spare footage there; cuts with none are skipped and reported.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          kind: { type: "string", enum: [...transitionKinds, "none"], description: '"none" removes the transition.' },
+          fromClipId: { type: "string", description: "The clip ending at the cut." },
+          toClipId: { type: "string", description: "The clip starting at the cut." },
+          nearSeconds: { type: "number", description: "Pick the cut closest to this time instead." },
+          allCuts: { type: "boolean", description: "Apply to every cut." },
+          durationSeconds: { type: "number", minimum: 0.1, maximum: 3, description: "Default 0.6." },
+          direction: { type: "string", enum: ["left", "right", "up", "down"], description: "wipe / slide only." }
+        },
+        required: ["kind"],
+        additionalProperties: false
+      },
+      run(input, { project }) {
+        const cuts = findCuts(project.getState().doc);
+        if (cuts.length === 0) return { ok: false, error: "There are no cuts: transitions need two clips touching on the same video track." };
+        let targets;
+        if (input.allCuts === true) targets = cuts;
+        else if (typeof input.fromClipId === "string" || typeof input.toClipId === "string") {
+          targets = cuts.filter((c) => (!input.fromClipId || c.fromClipId === input.fromClipId) && (!input.toClipId || c.toClipId === input.toClipId));
+        } else {
+          const at = toUs(input.nearSeconds) ?? project.getState().playheadUs;
+          targets = [cuts.reduce((a, b) => Math.abs(b.atUs - at) < Math.abs(a.atUs - at) ? b : a)];
+        }
+        if (targets.length === 0) return { ok: false, error: { error: "no cut matches", cuts: cuts.map(cutInfo) } };
+        const kind = String(input.kind);
+        const wanted = toUs(input.durationSeconds) ?? 6e5;
+        const commands = [];
+        const changes = [];
+        const skipped = [];
+        for (const cut of targets) {
+          if (cut.transition) commands.push({ type: "transition/remove", payload: { transitionId: cut.transition.id } });
+          if (kind === "none") {
+            if (cut.transition) changes.push(`Removed the transition at ${seconds(cut.atUs)}`);
+            continue;
+          }
+          const durationUs = Math.min(wanted, cut.maxTransitionUs);
+          if (durationUs < 1e5) {
+            skipped.push({ ...cutInfo(cut), reason: `no spare footage (${cut.short === "from" ? "the first clip ends where its media ends" : cut.short === "to" ? "the second clip starts at its media's start" : "both clips use all their media"})` });
+            if (cut.transition) commands.pop();
+            continue;
+          }
+          const params = input.direction && (kind === "wipe" || kind === "slide") ? { direction: input.direction } : void 0;
+          commands.push({ type: "transition/add", payload: { kind, fromClipId: cut.fromClipId, toClipId: cut.toClipId, durationUs, ...params ? { params } : {} } });
+          changes.push(`${cut.transition ? "Replaced the transition with" : "Added"} ${kind} at ${seconds(cut.atUs)} (${seconds(durationUs)})`);
+        }
+        if (commands.length) {
+          const result = applyCommands(project, commands);
+          if (!result.ok) return { ok: false, error: result };
+        }
+        return { ok: true, result: { changed: changes.length, skipped }, changes };
+      }
+    }),
+    defineTool({
+      name: "animate_clip",
+      description: `Give a visual clip (video, image, text) an entrance (in), a loop while on screen, and/or an exit (out), as keyframes. Slots you leave out keep their current animation; "none" removes one; reset:true removes all. In/out presets: ${presetIds("in").join(", ")}. Loops: ${presetIds("loop").join(", ")}. Exits stay on the clip's end through trims.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          clipId: { type: "string" },
+          in: { type: "string", enum: [...presetIds("in"), "none"] },
+          loop: { type: "string", enum: [...presetIds("loop"), "none"] },
+          out: { type: "string", enum: [...presetIds("out"), "none"] },
+          inSeconds: { type: "number", minimum: 0.2, maximum: 3, description: "Default 0.6." },
+          outSeconds: { type: "number", minimum: 0.2, maximum: 3, description: "Default 0.6." },
+          easing: { type: "string", enum: ANIMATION_EASINGS.map((e) => e.id), description: "Default smooth." },
+          reset: { type: "boolean" }
+        },
+        required: ["clipId"],
+        additionalProperties: false
+      },
+      run(input, { project }) {
+        const clip = project.getState().doc.clips[String(input.clipId)];
+        if (!clip) return { ok: false, error: `no clip "${input.clipId}"` };
+        if (clip.kind === "audio") return { ok: false, error: "audio clips have no picture to animate (use volume or fades)" };
+        const current = input.reset === true ? {} : readAnimation(clip).recipe;
+        const next = { ...current };
+        const easing = typeof input.easing === "string" ? input.easing : "smooth";
+        for (const slot of ["in", "loop", "out"]) {
+          const name = input[slot];
+          if (name === void 0) continue;
+          if (name === "none") {
+            delete next[slot];
+            continue;
+          }
+          const durationUs = slot === "loop" ? 0 : toUs(input[slot === "in" ? "inSeconds" : "outSeconds"]) ?? current[slot]?.durationUs ?? 6e5;
+          next[slot] = { preset: `${slot}:${name}`, durationUs, easing: slot === "loop" ? "linear" : easing };
+        }
+        const recipe = fitAnimation(next, clip.durationUs);
+        const result = applyCommands(project, animationCommands(clip, recipe));
+        if (!result.ok) return { ok: false, error: result };
+        const summary = describeAnimation(recipe) || "no animation";
+        return { ok: true, result: { clipId: clip.id, animation: summary }, changes: [`${clip.id}: ${summary}`] };
+      }
+    })
+  ];
+}
+function cutInfo(c) {
+  return { fromClipId: c.fromClipId, toClipId: c.toClipId, atSeconds: c.atUs / S, maxSeconds: c.maxTransitionUs / S, ...c.transition ? { transition: c.transition.kind } : {} };
+}
+function applyCommandsSchema(catalog) {
+  const [dispatch] = toToolDefinitions(catalog, { mode: "dispatch" });
+  return {
+    type: "object",
+    properties: {
+      commands: { type: "array", minItems: 1, items: dispatch.input_schema, description: "Commands applied in order, as one batch." }
+    },
+    required: ["commands"],
+    additionalProperties: false
+  };
+}
+
+// src/fork.ts
+import { createProject } from "@miraiclip/core";
+var seq = 0;
+var genId = (prefix) => `${prefix}-${Date.now().toString(36)}${(++seq).toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+function withExplicitIds(command) {
+  const p = command.payload ?? {};
+  const set = (field, prefix) => p[field] === void 0 ? { ...command, payload: { ...p, [field]: genId(prefix) } } : command;
+  switch (command.type) {
+    case "clip/split":
+    case "clip/duplicate":
+      return set("newClipId", "clip");
+    case "effect/add":
+      return set("effectId", "fx");
+    case "transition/add":
+      return set("id", "tr");
+    default:
+      return command;
+  }
+}
+function forkProject(project, options = {}) {
+  const fork = (options.createFork ?? ((doc) => createProject(doc)))(project.toJSON());
+  const state = project.getState();
+  fork.setPlayhead(state.playheadUs);
+  fork.setSelection([...state.selection]);
+  const ensure = options.ensureIds ?? withExplicitIds;
+  const recorded = [];
+  let depth = 0;
+  let buffer = [];
+  return {
+    ...fork,
+    get recorded() {
+      return recorded;
+    },
+    dispatch(command) {
+      const explicit = ensure(command);
+      const before = fork.getState().doc;
+      fork.dispatch(explicit);
+      if (fork.getState().doc === before) return;
+      if (depth > 0) buffer.push(explicit);
+      else recorded.push(explicit);
+    },
+    transaction(fn, label) {
+      if (depth > 0) {
+        fn();
+        return;
+      }
+      depth = 1;
+      buffer = [];
+      try {
+        fork.transaction(fn, label);
+        recorded.push(...buffer);
+      } finally {
+        depth = 0;
+        buffer = [];
+      }
+    }
+  };
+}
+function commitFork(project, fork, label) {
+  if (fork.recorded.length === 0) return { ok: true, applied: 0 };
+  try {
+    project.transaction(() => {
+      for (const command of fork.recorded) project.dispatch(command);
+    }, label);
+    return { ok: true, applied: fork.recorded.length };
+  } catch (err) {
+    return {
+      ok: false,
+      error: `The project changed while the assistant was working, so its edit no longer applies (${err?.message ?? err}). Ask again.`
+    };
+  }
+}
+
+// src/run.ts
+import { describeProject as describeProject2 } from "@miraiclip/core";
+var MAX_TOOL_RESULT = 2e4;
+var MAX_OLD_TOOL_RESULT = 2e3;
+var DEFAULT_INSTRUCTIONS = `You are the editing assistant inside a video editor. You change the user's project by calling tools; every change you make lands as ONE undo step when you finish, so act confidently.
+
+How to work:
+- The current project is summarized below. Clip, track and asset ids there are what tools expect. Call get_state to re-read it after big changes.
+- Prefer the high-level tools when they fit (add_transition, animate_clip, and any audio or media tools). Use apply_commands for everything else, batching related commands; look up a command's payload with get_command_schema the first time you use it.
+- Commands use integer microseconds (1 second = 1000000). High-level tools take seconds.
+- Positions (transform x, y) are fractions of the frame: 0.5, 0.5 is the center.
+- Only reference media that exists in the project or that a tool returned. Never invent file URLs.
+- If a tool fails, read the error, fix the input and retry. If something can't be done, say why.
+- If the request is ambiguous in a way that matters, ask one short question instead of guessing.
+
+When you're done, reply in one to three short sentences: what you changed, in plain words (times in seconds, names over ids). No markdown headings.`;
+function createAssistant(options) {
+  const tools = options.tools ?? editorTools();
+  const byName = new Map(tools.map((t) => [t.name, t]));
+  const specs = tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema }));
+  const maxSteps = options.maxSteps ?? 12;
+  return {
+    tools,
+    async run(project, request, turn = {}) {
+      const fork = forkProject(project, options.fork);
+      const emit = turn.onEvent ?? (() => {
+      });
+      const usage2 = { inputTokens: 0, outputTokens: 0 };
+      const changes = [];
+      const history = trimHistory(turn.history ?? []);
+      const added = [{ role: "user", content: request }];
+      const system = [
+        DEFAULT_INSTRUCTIONS,
+        options.instructions?.trim(),
+        `Current project:
+${describeProject2(fork.toJSON())}`,
+        turn.context?.trim() ? `What the user is looking at: ${turn.context.trim()}` : void 0
+      ].filter(Boolean).join("\n\n");
+      let reply = "";
+      let status = "no-changes";
+      let error;
+      try {
+        for (let step = 0; ; step++) {
+          if (step >= maxSteps) {
+            reply = (reply ? `${reply}
+
+` : "") + `I stopped after ${maxSteps} steps; what I finished is applied. Ask me to continue if there's more.`;
+            break;
+          }
+          emit({ type: "step", index: step });
+          const response = await options.model.complete(
+            {
+              messages: [{ role: "system", content: system }, ...history, ...added],
+              tools: specs,
+              ...options.modelId ? { model: options.modelId } : {},
+              ...options.maxOutputTokens ? { maxOutputTokens: options.maxOutputTokens } : {},
+              ...options.params ? { params: options.params } : {}
+            },
+            { ...turn.signal ? { signal: turn.signal } : {}, onText: (delta) => emit({ type: "text", delta }) }
+          );
+          usage2.inputTokens += response.usage?.inputTokens ?? 0;
+          usage2.outputTokens += response.usage?.outputTokens ?? 0;
+          added.push({ role: "assistant", content: response.content, ...response.toolCalls.length ? { toolCalls: response.toolCalls } : {} });
+          if (response.toolCalls.length === 0) {
+            reply = response.content.trim();
+            break;
+          }
+          for (const call of response.toolCalls) {
+            if (turn.signal?.aborted) throw abortError();
+            emit({ type: "tool-start", call });
+            const out = await runTool(byName.get(call.name), call, fork, turn.signal);
+            if (out.ok && out.changes?.length) changes.push(...out.changes);
+            emit({
+              type: "tool-end",
+              call,
+              ok: out.ok,
+              ...out.ok && out.changes?.length ? { changes: out.changes } : {},
+              ...!out.ok ? { error: short(out.error) } : {}
+            });
+            added.push({ role: "tool", toolCallId: call.id, name: call.name, content: cap(out.ok ? out.result ?? { ok: true } : { ok: false, error: out.error }, MAX_TOOL_RESULT) });
+          }
+        }
+        status = fork.recorded.length === 0 ? "no-changes" : turn.apply === "review" ? "review" : "applied";
+      } catch (err) {
+        status = turn.signal?.aborted || err?.name === "AbortError" ? "canceled" : "failed";
+        error = err?.message ?? String(err);
+      }
+      let committed = false;
+      let discarded = false;
+      const label = turn.label ?? `Assistant: ${request.length > 40 ? `${request.slice(0, 39)}\u2026` : request}`;
+      const apply = () => {
+        if (committed) return { ok: true, applied: 0 };
+        if (discarded) return { ok: false, error: "This edit was discarded." };
+        if (status === "failed" || status === "canceled") return { ok: false, error: error ?? status };
+        const result = commitFork(project, fork, label);
+        if (result.ok) committed = true;
+        return result;
+      };
+      if (status === "applied") {
+        const result = apply();
+        if (!result.ok) {
+          status = "failed";
+          error = result.error;
+        }
+      }
+      return {
+        reply,
+        changes,
+        commands: fork.recorded,
+        status,
+        ...error !== void 0 ? { error } : {},
+        preview: fork.toJSON(),
+        messages: [...history, ...added],
+        usage: usage2,
+        apply,
+        discard() {
+          if (!committed) discarded = true;
+        }
+      };
+    }
+  };
+}
+async function runTool(tool, call, project, signal) {
+  if (!tool) return { ok: false, error: `unknown tool "${call.name}"` };
+  if ("__invalidArguments" in call.arguments) return { ok: false, error: "the tool arguments weren't valid JSON; send a JSON object" };
+  try {
+    return await tool.run(call.arguments, { project, ...signal ? { signal } : {} });
+  } catch (err) {
+    if (err?.name === "AbortError") throw err;
+    return { ok: false, error: err?.message ?? String(err) };
+  }
+}
+function cap(value, max) {
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  return text.length > max ? `${text.slice(0, max)}\u2026 [truncated ${text.length - max} chars]` : text;
+}
+var short = (e) => {
+  const text = typeof e === "string" ? e : JSON.stringify(e);
+  return text.length > 300 ? `${text.slice(0, 299)}\u2026` : text;
+};
+function trimHistory(history) {
+  const answered = new Set(history.flatMap((m) => m.role === "tool" ? [m.toolCallId] : []));
+  const out = [];
+  for (const m of history) {
+    if (m.role === "system") continue;
+    if (m.role === "tool") {
+      out.push(m.content.length > MAX_OLD_TOOL_RESULT ? { ...m, content: `${m.content.slice(0, MAX_OLD_TOOL_RESULT)}\u2026 [truncated]` } : m);
+      continue;
+    }
+    out.push(m);
+    if (m.role === "assistant") {
+      for (const call of m.toolCalls ?? []) {
+        if (!answered.has(call.id)) out.push({ role: "tool", toolCallId: call.id, name: call.name, content: '{"ok":false,"error":"not run: the request was interrupted"}' });
+      }
+    }
+  }
+  return out;
+}
+function abortError() {
+  const err = new Error("canceled");
+  err.name = "AbortError";
+  return err;
+}
+
+// src/testing.ts
+function scriptedChatModel(steps, options = {}) {
+  const requests = [];
+  let i = 0;
+  const model = defineChatModel({
+    id: options.id ?? "scripted",
+    label: "Scripted model",
+    async complete(request, opts = {}) {
+      requests.push(structuredClone(request));
+      let step = steps[Math.min(i, steps.length - 1)] ?? "Done.";
+      while (typeof step === "function") step = step(request, i);
+      i++;
+      const s = typeof step === "string" ? { text: step } : step;
+      if (s.text) opts.onText?.(s.text);
+      const toolCalls = (s.toolCalls ?? []).map((c, n) => ({ id: c.id ?? `call_${i}_${n}`, name: c.name, arguments: c.arguments }));
+      return { content: s.text ?? "", toolCalls, finish: toolCalls.length ? "tool_calls" : "stop", usage: { inputTokens: 10, outputTokens: 5 } };
+    }
+  });
+  return Object.assign(model, { requests });
+}
+export {
+  ChatModelError,
+  DEFAULT_INSTRUCTIONS,
+  applyCommandsSchema,
+  commitFork,
+  createAssistant,
+  createChatHandler,
+  defineChatModel,
+  defineTool,
+  describeCommands,
+  editorTools,
+  forkProject,
+  openAIChatModel,
+  parseToolArguments,
+  remoteChatModel,
+  scriptedChatModel,
+  toOpenAIMessages,
+  toolsFromDefinitions,
+  withExplicitIds
+};
+//# sourceMappingURL=index.js.map