@usestratus/sdk 1.6.0 → 1.9.0

package/dist/ai-sdk/index.js

@@ -0,0 +1,741 @@
+import { resumeRun, stream } from "../core/run";
+import { resumeSession } from "../core/session";
+function isUIMessage(message) {
+    return "parts" in message && Array.isArray(message.parts);
+}
+function stringifyOutput(value) {
+    if (typeof value === "string")
+        return value;
+    if (value && typeof value === "object" && "type" in value) {
+        const typed = value;
+        if (typed.type === "text" || typed.type === "error-text")
+            return String(typed.value ?? "");
+        if (typed.type === "execution-denied")
+            return typed.reason ?? "Tool execution denied";
+    }
+    return JSON.stringify(value);
+}
+function parseJsonish(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function toolNameFromUIPart(part) {
+    if (part.type === "dynamic-tool" && typeof part.toolName === "string")
+        return part.toolName;
+    if (part.type.startsWith("tool-"))
+        return part.type.slice("tool-".length);
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isTextUIPart(part) {
+    return part.type === "text" && typeof part.text === "string";
+}
+function isFileUIPart(part) {
+    return (part.type === "file" &&
+        typeof part.url === "string" &&
+        typeof part.mediaType === "string");
+}
+function isModelTextPart(part) {
+    return part.type === "text" && typeof part.text === "string";
+}
+function isModelToolCallPart(part) {
+    return (part.type === "tool-call" &&
+        typeof part.toolCallId === "string" &&
+        typeof part.toolName === "string");
+}
+function isModelToolResultPart(part) {
+    return (part.type === "tool-result" && typeof part.toolCallId === "string");
+}
+function imagePartFromUrl(url) {
+    return { type: "image_url", image_url: { url } };
+}
+function filePartFromUrl(url, filename) {
+    return { type: "file", file: { url }, filename };
+}
+function contentPartFromModelPart(part) {
+    if (isModelTextPart(part))
+        return { type: "text", text: part.text };
+    if (part.type === "image") {
+        const image = part.image;
+        if (typeof image === "string")
+            return imagePartFromUrl(image);
+        if (image instanceof URL)
+            return imagePartFromUrl(image.toString());
+        if (isRecord(image) && image.type === "reference" && typeof image.reference === "string") {
+            return { type: "image_url", image_url: { file_id: image.reference } };
+        }
+    }
+    if (part.type === "file") {
+        const file = part;
+        const filename = typeof file.filename === "string" ? file.filename : undefined;
+        if (typeof file.data === "string")
+            return filePartFromUrl(file.data, filename);
+        if (file.data instanceof URL)
+            return filePartFromUrl(file.data.toString(), filename);
+        if (isRecord(file.data) && file.data.type === "url" && typeof file.data.url === "string") {
+            return filePartFromUrl(file.data.url, filename);
+        }
+        if (isRecord(file.data) &&
+            file.data.type === "reference" &&
+            typeof file.data.reference === "string") {
+            return { type: "file", file: { file_id: file.data.reference }, filename };
+        }
+    }
+    return undefined;
+}
+function contentPartFromUIPart(part, options) {
+    if (isTextUIPart(part))
+        return { type: "text", text: part.text };
+    if (isFileUIPart(part)) {
+        if (part.mediaType.startsWith("image/"))
+            return imagePartFromUrl(part.url);
+        return filePartFromUrl(part.url, part.filename);
+    }
+    if (part.type.startsWith("data-"))
+        return options?.convertDataPart?.(part);
+    return undefined;
+}
+function normalizeContent(parts) {
+    if (parts.length === 0)
+        return "";
+    if (parts.every((part) => part.type === "text")) {
+        return parts.map((part) => part.text).join("");
+    }
+    return parts;
+}
+function fromUIMessage(message, options) {
+    if (message.role === "system") {
+        return [
+            {
+                role: "system",
+                content: message.parts.map((p) => (isTextUIPart(p) ? p.text : "")).join(""),
+            },
+        ];
+    }
+    if (message.role === "user") {
+        const parts = message.parts
+            .map((part) => contentPartFromUIPart(part, options))
+            .filter((part) => part !== undefined);
+        return [{ role: "user", content: normalizeContent(parts) }];
+    }
+    const text = message.parts
+        .filter(isTextUIPart)
+        .map((part) => part.text)
+        .join("");
+    const toolCalls = [];
+    const toolMessages = [];
+    for (const part of message.parts) {
+        const toolName = toolNameFromUIPart(part);
+        if (!toolName || !("toolCallId" in part))
+            continue;
+        const toolPart = part;
+        const input = "input" in part ? part.input : undefined;
+        if (toolPart.state === "input-available" ||
+            toolPart.state === "approval-requested" ||
+            toolPart.state === "approval-responded" ||
+            toolPart.state === "output-available" ||
+            toolPart.state === "output-error" ||
+            toolPart.state === "output-denied") {
+            toolCalls.push({
+                id: toolPart.toolCallId,
+                type: "function",
+                function: { name: toolName, arguments: JSON.stringify(input ?? {}) },
+            });
+        }
+        if (toolPart.state === "output-available") {
+            toolMessages.push({
+                role: "tool",
+                tool_call_id: toolPart.toolCallId,
+                content: stringifyOutput(toolPart.output),
+            });
+        }
+        if (toolPart.state === "output-error") {
+            toolMessages.push({
+                role: "tool",
+                tool_call_id: toolPart.toolCallId,
+                content: toolPart.errorText ?? "Tool execution failed",
+            });
+        }
+        if (toolPart.state === "output-denied") {
+            toolMessages.push({
+                role: "tool",
+                tool_call_id: toolPart.toolCallId,
+                content: toolPart.approval?.reason ?? "Tool execution denied",
+            });
+        }
+    }
+    const assistant = {
+        role: "assistant",
+        content: text || null,
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+    };
+    return [assistant, ...toolMessages];
+}
+function fromModelMessage(message) {
+    if (message.role === "system")
+        return [{ role: "system", content: message.content }];
+    if (message.role === "user") {
+        if (typeof message.content === "string")
+            return [{ role: "user", content: message.content }];
+        const parts = message.content
+            .map(contentPartFromModelPart)
+            .filter((part) => part !== undefined);
+        return [{ role: "user", content: normalizeContent(parts) }];
+    }
+    if (message.role === "tool") {
+        return message.content.filter(isModelToolResultPart).map((part) => ({
+            role: "tool",
+            tool_call_id: String(part.toolCallId),
+            content: stringifyOutput(part.output),
+        }));
+    }
+    if (typeof message.content === "string") {
+        return [{ role: "assistant", content: message.content }];
+    }
+    const text = message.content
+        .filter(isModelTextPart)
+        .map((part) => part.text)
+        .join("");
+    const toolCalls = message.content.filter(isModelToolCallPart).map((part) => ({
+        id: part.toolCallId,
+        type: "function",
+        function: { name: part.toolName, arguments: JSON.stringify(part.input ?? {}) },
+    }));
+    return [
+        {
+            role: "assistant",
+            content: text || null,
+            ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+        },
+    ];
+}
+export function fromAISDKMessages(messages, options) {
+    return messages.flatMap((message) => isUIMessage(message) ? fromUIMessage(message, options) : fromModelMessage(message));
+}
+export function toAISDKUIMessages(messagesOrSnapshot) {
+    const messages = Array.isArray(messagesOrSnapshot)
+        ? messagesOrSnapshot
+        : "messages" in messagesOrSnapshot
+            ? messagesOrSnapshot.messages
+            : [];
+    const toolResults = new Map();
+    const uiMessages = [];
+    for (const message of messages) {
+        if (message.role === "tool") {
+            toolResults.set(message.tool_call_id, message.content);
+        }
+    }
+    for (const message of messages) {
+        if (message.role === "tool") {
+            continue;
+        }
+        if (message.role === "developer")
+            continue;
+        if (message.role === "assistant") {
+            const parts = contentToUIParts(message.content);
+            for (const toolCall of message.tool_calls ?? []) {
+                const toolName = toolCall.function.name;
+                const output = toolResults.get(toolCall.id);
+                parts.push({
+                    type: `tool-${toolName}`,
+                    toolCallId: toolCall.id,
+                    state: output === undefined ? "input-available" : "output-available",
+                    input: parseJsonish(toolCall.function.arguments),
+                    ...(output === undefined ? {} : { output }),
+                });
+            }
+            uiMessages.push({
+                id: crypto.randomUUID(),
+                role: "assistant",
+                parts,
+            });
+            continue;
+        }
+        uiMessages.push({
+            id: crypto.randomUUID(),
+            role: message.role,
+            parts: userOrSystemContentToUIParts(message.content),
+        });
+    }
+    return uiMessages;
+}
+export function toSessionSnapshotFromAISDKMessages(messages, options) {
+    return {
+        id: options?.id ?? crypto.randomUUID(),
+        messages: fromAISDKMessages(messages, options).filter((message) => message.role !== "system"),
+    };
+}
+export function resumeSessionFromAISDKMessages(messages, config, options) {
+    return resumeSession(toSessionSnapshotFromAISDKMessages(messages, options), config);
+}
+function contentToUIParts(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return [];
+}
+function userOrSystemContentToUIParts(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    return content.flatMap((part) => {
+        if (part.type === "text")
+            return [{ type: "text", text: part.text }];
+        if (part.type === "image_url" && "url" in part.image_url) {
+            return [{ type: "file", url: part.image_url.url, mediaType: "image" }];
+        }
+        if (part.type === "file" && "url" in part.file) {
+            return [
+                {
+                    type: "file",
+                    url: part.file.url,
+                    mediaType: "application/octet-stream",
+                    filename: part.filename,
+                },
+            ];
+        }
+        return [];
+    });
+}
+export function toAISDKUIMessage(result, options) {
+    const messages = Array.isArray(result) ? result : result.messages;
+    const lastAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+    return {
+        id: options?.id ?? crypto.randomUUID(),
+        role: "assistant",
+        metadata: options?.metadata,
+        parts: lastAssistant ? contentToUIParts(lastAssistant.content) : [],
+    };
+}
+function finishReasonFromEvent(event) {
+    switch (event.response.finishReason) {
+        case "stop":
+        case "length":
+        case "content_filter":
+            return event.response.finishReason;
+        case "tool_calls":
+            return "tool-calls";
+        default:
+            return event.response.finishReason;
+    }
+}
+export function toAISDKToolApprovalRequests(interrupted) {
+    return interrupted.pendingToolCalls.map((call) => ({
+        type: "tool-approval-request",
+        approvalId: call.toolCallId,
+        toolCallId: call.toolCallId,
+        isAutomatic: false,
+    }));
+}
+export function approvalsFromAISDKMessages(messages, pendingToolCalls) {
+    const pending = new Set(pendingToolCalls.map((call) => call.toolCallId));
+    const approvals = new Map();
+    for (const message of messages) {
+        if (!isUIMessage(message))
+            continue;
+        for (const part of message.parts) {
+            const toolName = toolNameFromUIPart(part);
+            if (!toolName || !("toolCallId" in part))
+                continue;
+            const toolPart = part;
+            if (!pending.has(toolPart.toolCallId))
+                continue;
+            if (toolPart.state === "approval-responded" || toolPart.state === "output-denied") {
+                const approved = toolPart.approval?.approved === true;
+                approvals.set(toolPart.toolCallId, {
+                    toolCallId: toolPart.toolCallId,
+                    decision: approved ? "approve" : "deny",
+                    denyMessage: approved
+                        ? undefined
+                        : (toolPart.approval?.reason ?? "Tool call denied by user"),
+                });
+            }
+        }
+    }
+    return [...approvals.values()];
+}
+export async function* toAISDKUIMessageChunks(events, options) {
+    const textId = options?.textId ?? "stratus-text";
+    const toolInputs = new Map();
+    let startedText = false;
+    let endedText = false;
+    if (options?.sendStart !== false) {
+        yield {
+            type: "start",
+            messageId: options?.messageId,
+            messageMetadata: options?.messageMetadata,
+        };
+    }
+    for await (const event of events) {
+        switch (event.type) {
+            case "content_delta":
+                if (!startedText) {
+                    startedText = true;
+                    yield { type: "text-start", id: textId };
+                }
+                yield { type: "text-delta", id: textId, delta: event.content };
+                break;
+            case "tool_call_start":
+                toolInputs.set(event.toolCall.id, {
+                    toolName: event.toolCall.name,
+                    text: "",
+                    available: false,
+                });
+                yield {
+                    type: "tool-input-start",
+                    toolCallId: event.toolCall.id,
+                    toolName: event.toolCall.name,
+                };
+                break;
+            case "tool_call_delta": {
+                const input = toolInputs.get(event.toolCallId);
+                if (input)
+                    input.text += event.arguments;
+                yield {
+                    type: "tool-input-delta",
+                    toolCallId: event.toolCallId,
+                    inputTextDelta: event.arguments,
+                };
+                break;
+            }
+            case "tool_call_done": {
+                const input = toolInputs.get(event.toolCallId);
+                if (input && !input.available) {
+                    input.available = true;
+                    yield {
+                        type: "tool-input-available",
+                        toolCallId: event.toolCallId,
+                        toolName: input.toolName,
+                        input: parseJsonish(input.text || "{}"),
+                    };
+                }
+                break;
+            }
+            case "done":
+                if (startedText && !endedText) {
+                    endedText = true;
+                    yield { type: "text-end", id: textId };
+                }
+                for (const toolCall of event.response.toolCalls) {
+                    if (toolInputs.has(toolCall.id))
+                        continue;
+                    yield {
+                        type: "tool-input-available",
+                        toolCallId: toolCall.id,
+                        toolName: toolCall.function.name,
+                        input: parseJsonish(toolCall.function.arguments),
+                    };
+                }
+                if (options?.sendFinish !== false) {
+                    yield {
+                        type: "finish",
+                        finishReason: finishReasonFromEvent(event),
+                        messageMetadata: options?.messageMetadata,
+                    };
+                }
+                break;
+            default:
+                yield { type: "data-stratus-event", data: event };
+        }
+    }
+}
+async function* appendApprovalRequests(events, result, options) {
+    yield* toAISDKUIMessageChunks(events, { ...options, sendFinish: false });
+    const finalResult = await result;
+    if (finalResult.interrupted) {
+        yield* toAISDKToolApprovalRequests(finalResult);
+        if (options?.sendFinish !== false) {
+            yield {
+                type: "finish",
+                finishReason: "tool-calls",
+                messageMetadata: options?.messageMetadata,
+            };
+        }
+        return;
+    }
+    if (options?.sendFinish !== false) {
+        yield {
+            type: "finish",
+            finishReason: mapFinishReason(finalResult.finishReason),
+            messageMetadata: options?.messageMetadata,
+        };
+    }
+}
+export function toAISDKUIMessageStream(events, options) {
+    const chunks = toAISDKUIMessageChunks(events, options);
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await chunks.next();
+            if (next.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(next.value);
+        },
+        async cancel() {
+            await chunks.return?.(undefined);
+        },
+    });
+}
+function asyncIterableToReadableStream(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await iterator.next();
+            if (next.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(next.value);
+        },
+        async cancel() {
+            await iterator.return?.();
+        },
+    });
+}
+function jsonToSseStream(stream) {
+    return stream.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);
+        },
+    }));
+}
+export function createAISDKUIMessageStreamResponse(options) {
+    let sseStream = jsonToSseStream(options.stream);
+    if (options.consumeSseStream) {
+        const [primary, secondary] = sseStream.tee();
+        sseStream = primary;
+        options.consumeSseStream({ stream: secondary });
+    }
+    const headers = new Headers(options.headers);
+    headers.set("content-type", "text/event-stream; charset=utf-8");
+    headers.set("x-vercel-ai-ui-message-stream", "v1");
+    return new Response(sseStream.pipeThrough(new TextEncoderStream()), {
+        status: options.status,
+        statusText: options.statusText,
+        headers,
+    });
+}
+export function createStratusChatResponse(options) {
+    const input = fromAISDKMessages(options.messages, {
+        convertDataPart: options.convertDataPart,
+    });
+    const streamed = stream(options.agent, input, options.runOptions);
+    const uiStream = asyncIterableToReadableStream(appendApprovalRequests(streamed.stream, streamed.result, {
+        messageId: options.messageId,
+        messageMetadata: options.messageMetadata,
+    }));
+    return createAISDKUIMessageStreamResponse({ ...options, stream: uiStream });
+}
+export function resumeStratusChatResponse(options) {
+    const approvals = approvalsFromAISDKMessages(options.messages, options.interrupted.pendingToolCalls);
+    const result = resumeRun(options.interrupted, approvals, options.runOptions);
+    const uiStream = asyncIterableToReadableStream((async function* () {
+        yield {
+            type: "start",
+            messageId: options.messageId,
+            messageMetadata: options.messageMetadata,
+        };
+        try {
+            const resumed = await result;
+            if (resumed.interrupted) {
+                yield* toAISDKToolApprovalRequests(resumed);
+                yield {
+                    type: "finish",
+                    finishReason: "tool-calls",
+                    messageMetadata: options.messageMetadata,
+                };
+                return;
+            }
+            const message = toAISDKUIMessage(resumed, {
+                id: options.messageId,
+                metadata: options.messageMetadata,
+            });
+            const textPart = message.parts.find(isTextUIPart);
+            if (textPart) {
+                const textId = "stratus-text";
+                yield { type: "text-start", id: textId };
+                yield { type: "text-delta", id: textId, delta: textPart.text };
+                yield { type: "text-end", id: textId };
+            }
+            yield {
+                type: "finish",
+                finishReason: mapFinishReason(resumed.finishReason),
+                messageMetadata: options.messageMetadata,
+            };
+        }
+        catch (error) {
+            yield {
+                type: "error",
+                errorText: error instanceof Error ? error.message : String(error),
+            };
+        }
+    })());
+    return createAISDKUIMessageStreamResponse({ ...options, stream: uiStream });
+}
+export function toAISDKToolSet(tools, context) {
+    return Object.fromEntries(tools.map((tool) => [
+        tool.name,
+        {
+            description: tool.description,
+            inputSchema: tool.parameters,
+            execute: (input, options) => tool.execute(context, input, options),
+        },
+    ]));
+}
+function mapFinishReason(reason) {
+    switch (reason) {
+        case "stop":
+            return "stop";
+        case "length":
+            return "length";
+        case "content_filter":
+            return "content-filter";
+        case "tool_calls":
+            return "tool-calls";
+        default:
+            return "unknown";
+    }
+}
+function mapUsage(response) {
+    return {
+        inputTokens: response.usage?.promptTokens ?? 0,
+        outputTokens: response.usage?.completionTokens ?? 0,
+        totalTokens: response.usage?.totalTokens ?? 0,
+    };
+}
+function requestFromAISDKCall(options) {
+    const messages = fromAISDKMessages((options.messages ?? options.prompt ?? []));
+    const reasoningEffort = typeof options.reasoningEffort === "string"
+        ? options.reasoningEffort
+        : undefined;
+    return {
+        messages,
+        tools: options.tools?.map((tool) => ({
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description ?? tool.name,
+                parameters: tool.inputSchema ?? tool.parameters ?? { type: "object", properties: {} },
+            },
+        })),
+        modelSettings: {
+            temperature: typeof options.temperature === "number" ? options.temperature : undefined,
+            topP: typeof options.topP === "number" ? options.topP : undefined,
+            maxTokens: typeof options.maxOutputTokens === "number" ? options.maxOutputTokens : undefined,
+            reasoningEffort,
+        },
+    };
+}
+export function toAISDKLanguageModel(model, options) {
+    return {
+        specificationVersion: "v2",
+        provider: options?.provider ?? "stratus",
+        modelId: options?.modelId ?? "stratus-model",
+        supportedUrls: {},
+        async doGenerate(callOptions) {
+            const response = await model.getResponse(requestFromAISDKCall(callOptions), {
+                signal: callOptions.abortSignal,
+            });
+            return {
+                content: [
+                    ...(response.content ? [{ type: "text", text: response.content }] : []),
+                    ...response.toolCalls.map((toolCall) => ({
+                        type: "tool-call",
+                        toolCallId: toolCall.id,
+                        toolName: toolCall.function.name,
+                        input: parseJsonish(toolCall.function.arguments),
+                    })),
+                ],
+                finishReason: mapFinishReason(response.finishReason),
+                usage: mapUsage(response),
+                response: { id: response.responseId },
+            };
+        },
+        async doStream(callOptions) {
+            const request = requestFromAISDKCall(callOptions);
+            const events = model.getStreamedResponse(request, { signal: callOptions.abortSignal });
+            return {
+                stream: asyncIterableToReadableStream((async function* () {
+                    for await (const event of events) {
+                        if (event.type === "content_delta") {
+                            yield { type: "text-delta", id: "stratus-text", delta: event.content };
+                        }
+                        else if (event.type === "done") {
+                            for (const toolCall of event.response.toolCalls) {
+                                yield {
+                                    type: "tool-call",
+                                    toolCallId: toolCall.id,
+                                    toolName: toolCall.function.name,
+                                    input: parseJsonish(toolCall.function.arguments),
+                                };
+                            }
+                            yield {
+                                type: "finish",
+                                finishReason: mapFinishReason(event.response.finishReason),
+                                usage: mapUsage(event.response),
+                            };
+                        }
+                    }
+                })()),
+            };
+        },
+    };
+}
+export async function* toOpenAIAgentsStyleStreamEvents(events) {
+    const toolInputs = new Map();
+    for await (const event of events) {
+        yield { type: "raw_model_stream_event", data: event, source: "stratus" };
+        switch (event.type) {
+            case "content_delta":
+                yield {
+                    type: "run_item_stream_event",
+                    name: "message_output_created",
+                    item: { content: event.content },
+                };
+                break;
+            case "tool_call_start":
+                toolInputs.set(event.toolCall.id, { toolName: event.toolCall.name, text: "" });
+                yield {
+                    type: "run_item_stream_event",
+                    name: "tool_called",
+                    item: { toolCallId: event.toolCall.id, toolName: event.toolCall.name },
+                };
+                break;
+            case "tool_call_delta": {
+                const input = toolInputs.get(event.toolCallId);
+                if (input)
+                    input.text += event.arguments;
+                break;
+            }
+            case "tool_call_done": {
+                const input = toolInputs.get(event.toolCallId);
+                yield {
+                    type: "run_item_stream_event",
+                    name: "tool_output",
+                    item: {
+                        toolCallId: event.toolCallId,
+                        toolName: input?.toolName,
+                        input: input ? parseJsonish(input.text || "{}") : undefined,
+                    },
+                };
+                break;
+            }
+            case "subagent_start":
+                yield { type: "agent_updated_stream_event", agent: { name: event.agentName } };
+                break;
+            case "subagent_end":
+                yield {
+                    type: "run_item_stream_event",
+                    name: "handoff_occurred",
+                    item: { agentName: event.agentName, result: event.result },
+                };
+                break;
+        }
+    }
+}
+//# sourceMappingURL=index.js.map