Editing assistant

import { createAssistant, openAIChatModel } from "@miraiclip/assistant";

const assistant = createAssistant({
  model: openAIChatModel({ apiKey: process.env.OPENAI_API_KEY, model: "gpt-5.4-mini" }),
});

const turn = await assistant.run(project, "start the title at 1 second");
turn.reply;   // "Moved the title to 1 s."
turn.changes; // ["Moved clip title to 1s"]
project.undo(); // reverts the whole request

import { createAssistant, type ChatMessage, type ChatModel } from "@miraiclip/assistant";

declare const model: ChatModel;
const assistant = createAssistant({ model });
let history: ChatMessage[] = [];
const controller = new AbortController();

const turn = await assistant.run(project, "make the title pop in", {
  history,
  context: "Selected: clip title. Playhead: 4.2s.",
  signal: controller.signal,
  onEvent: (event) => {
    if (event.type === "text") console.log(event.delta);
    if (event.type === "tool-end") console.log(event.call.name, event.ok, event.changes);
  },
});
history = turn.messages; // continue the conversation next time

import { createAssistant, type ChatModel } from "@miraiclip/assistant";

declare const model: ChatModel;
const assistant = createAssistant({ model });

const turn = await assistant.run(project, "move the title to 2 seconds", { apply: "review" });
turn.status;  // "review": the project is unchanged
turn.preview; // the edited document: render it to show the result
turn.changes; // show these with Apply / Discard buttons

const result = turn.apply(); // or turn.discard()
if (!result.ok) console.warn(result.error); // the project changed in a way the edit no longer fits

import { createAssistant, defineTool, editorTools, type ChatModel } from "@miraiclip/assistant";

declare const model: ChatModel;

const addEndCard = defineTool({
  name: "add_end_card",
  description: "Add a 2-second end card with the given text after the last clip.",
  inputSchema: {
    type: "object",
    properties: { text: { type: "string" } },
    required: ["text"],
    additionalProperties: false,
  },
  run(input, { project }) {
    // `project` is the turn's working copy: edit through it
    const clips = Object.values(project.getState().doc.clips);
    const endUs = Math.max(0, ...clips.map((clip) => clip.startUs + clip.durationUs));
    project.dispatch({ type: "track/add", payload: { id: "end-card", kind: "video" } });
    project.dispatch({
      type: "clip/add",
      payload: {
        kind: "text", id: "end-card-text", trackId: "end-card", startUs: endUs, durationUs: 2_000_000,
        text: String(input["text"]), fontFamily: "Inter", fontSizePx: 64, color: "#ffffff",
      },
    });
    return { ok: true, changes: ["Added an end card"] };
  },
});

const assistant = createAssistant({
  model,
  tools: [...editorTools(), addEndCard],
  instructions: "Keep titles under six words.",
});

import type { ChatOptions, ChatRequest, ChatResponse } from "@miraiclip/assistant";

interface ChatModel {
  id: string;                                  // "openai"; letters, digits, - or _
  label: string;
  models?: { id: string; label?: string }[];   // the first is the default
  complete(request: ChatRequest, options?: ChatOptions): Promise<ChatResponse>;
}

import { openAIChatModel } from "@miraiclip/assistant";

const local = openAIChatModel({
  id: "ollama",
  label: "Ollama",
  baseUrl: "http://localhost:11434/v1",
  model: "llama3.1",
});

import { defineChatModel, type ChatRequest, type ChatResponse } from "@miraiclip/assistant";

declare function callMyVendor(request: ChatRequest, signal?: AbortSignal): Promise<ChatResponse>;

const model = defineChatModel({
  id: "my-vendor",
  label: "My vendor",
  async complete(request, options) {
    const response = await callMyVendor(request, options?.signal);
    options?.onText?.(response.content); // adapters that can't stream call it once
    return response;
  },
});

import { openAIChatModel, rateLimitedChatModel } from "@miraiclip/assistant";

const model = rateLimitedChatModel(openAIChatModel({ apiKey: process.env.OPENAI_API_KEY, model: "gpt-5.4-mini" }), {
  tokensPerMinute: 150_000,
  requestsPerMinute: 400,
});

// Server: any Fetch API runtime (Node 18+, edge runtimes, Next, Hono…)
import { createChatHandler, openAIChatModel } from "@miraiclip/assistant";

declare function isSignedIn(request: Request): boolean;

const handle = createChatHandler(openAIChatModel({ apiKey: process.env.OPENAI_API_KEY, model: "gpt-5.4-mini" }), {
  basePath: "/api/assistant",
  authorize: (request) => (isSignedIn(request) ? undefined : new Response("sign in", { status: 401 })),
  prepare: (request) => ({ ...request, maxOutputTokens: 2000 }),
});

export async function fetchHandler(request: Request): Promise<Response> {
  return (await handle(request)) ?? new Response("not found", { status: 404 });
}

// Browser
import { createAssistant, remoteChatModel } from "@miraiclip/assistant";

const assistant = createAssistant({ model: await remoteChatModel("/api/assistant") });

import { createAssistant, scriptedChatModel } from "@miraiclip/assistant";

const model = scriptedChatModel([
  { toolCalls: [{ name: "apply_commands", arguments: { commands: [{ type: "clip/move", payload: { clipId: "title", startUs: 1_000_000 } }] } }] },
  "Moved the title to 1 s.",
]);

const turn = await createAssistant({ model }).run(project, "start the title at 1 second");
turn.status;    // "applied"
model.requests; // every ChatRequest the assistant sent