| export type ChatMessage = { |
| role: "system" | "user" | "assistant"; |
| content: string; |
| }; |
|
|
| export type ReasoningEffort = "auto" | "none" | "low" | "medium" | "high" | "xhigh"; |
|
|
| export type ChatToolActivity = { |
| id: string; |
| type: string; |
| name: string; |
| status: "in_progress" | "completed" | "failed"; |
| detail: string; |
| }; |
|
|
| export type ChatStreamSnapshot = { |
| text: string; |
| reasoning: string; |
| tools: ChatToolActivity[]; |
| }; |
|
|
| export type ChatResponseResult = ChatStreamSnapshot; |
|
|
| export type ImageResult = { |
| url: string; |
| revisedPrompt?: string; |
| }; |
|
|
| export type VideoStatus = { |
| status: "pending" | "done" | "failed"; |
| model?: string; |
| progress: number; |
| video?: { url: string; duration?: number; respectModeration?: boolean }; |
| error?: { code?: string; message: string }; |
| }; |
|
|
| class CreativeApiError extends Error { |
| readonly status: number; |
| readonly code?: string; |
|
|
| constructor(status: number, message: string, code?: string) { |
| super(message); |
| this.name = "CreativeApiError"; |
| this.status = status; |
| this.code = code; |
| } |
| } |
|
|
| type RequestOptions = { |
| method?: "GET" | "POST"; |
| body?: Record<string, unknown>; |
| signal?: AbortSignal; |
| }; |
|
|
| export async function createChatResponse(input: { |
| apiKey: string; |
| model: string; |
| messages: ChatMessage[]; |
| promptCacheKey?: string; |
| reasoningEffort: ReasoningEffort; |
| webSearch: boolean; |
| xSearch: boolean; |
| onUpdate?: (snapshot: ChatStreamSnapshot) => void; |
| signal?: AbortSignal; |
| }): Promise<ChatResponseResult> { |
| const body: Record<string, unknown> = { |
| model: input.model, |
| input: input.messages.map(({ role, content }) => ({ role, content })), |
| stream: true, |
| store: false, |
| }; |
| if (input.promptCacheKey) body.prompt_cache_key = input.promptCacheKey; |
| if (input.reasoningEffort === "auto") body.reasoning = { summary: "auto" }; |
| else if (input.reasoningEffort !== "none") body.reasoning = { effort: input.reasoningEffort, summary: "auto" }; |
| else body.reasoning = { effort: "none" }; |
| const tools: Array<{ type: string }> = []; |
| if (input.webSearch) tools.push({ type: "web_search" }); |
| if (input.xSearch) tools.push({ type: "x_search" }); |
| if (tools.length > 0) body.tools = tools; |
| return publicResponsesStream(input.apiKey, body, input.onUpdate, input.signal); |
| } |
|
|
| export async function generateImage(input: { |
| apiKey: string; |
| model: string; |
| prompt: string; |
| count: number; |
| aspectRatio: string; |
| resolution: string; |
| signal?: AbortSignal; |
| }): Promise<ImageResult[]> { |
| const payload = await publicApiRequest( |
| input.apiKey, |
| "/images/generations", |
| { |
| method: "POST", |
| body: { |
| model: input.model, |
| prompt: input.prompt, |
| n: input.count, |
| aspect_ratio: input.aspectRatio, |
| resolution: input.resolution, |
| response_format: "url", |
| stream: false, |
| }, |
| signal: input.signal, |
| }, |
| ); |
| const images = readImages(payload); |
| if (images.length === 0) throw new CreativeApiError(200, "The image response did not contain any images", "invalid_response"); |
| return images.map((image) => ({ ...image, url: resolveMediaURL(image.url) })); |
| } |
|
|
| export async function createVideo(input: { |
| apiKey: string; |
| model: string; |
| prompt: string; |
| imageURL?: string; |
| duration: number; |
| aspectRatio: string; |
| resolution: string; |
| signal?: AbortSignal; |
| }): Promise<string> { |
| const body: Record<string, unknown> = { |
| model: input.model, |
| prompt: input.prompt, |
| duration: input.duration, |
| aspect_ratio: input.aspectRatio, |
| resolution: input.resolution, |
| }; |
| if (input.imageURL) body.image = { url: input.imageURL }; |
| const payload = await publicApiRequest( |
| input.apiKey, |
| "/videos/generations", |
| { method: "POST", body, signal: input.signal }, |
| ); |
| const requestId = readVideoRequestID(payload); |
| if (!requestId) { |
| throw new CreativeApiError(200, "The video response did not contain a request ID", "invalid_response"); |
| } |
| return requestId; |
| } |
|
|
| export async function getVideo(input: { |
| apiKey: string; |
| requestId: string; |
| signal?: AbortSignal; |
| }): Promise<VideoStatus> { |
| const payload = await publicApiRequest( |
| input.apiKey, |
| `/videos/${encodeURIComponent(input.requestId)}`, |
| { method: "GET", signal: input.signal }, |
| ); |
| const status = readVideoStatus(payload); |
| return status.video ? { ...status, video: { ...status.video, url: resolveMediaURL(status.video.url) } } : status; |
| } |
|
|
| async function publicApiRequest(apiKey: string, path: string, options: RequestOptions): Promise<unknown> { |
| const headers = new Headers({ Accept: "application/json", Authorization: `Bearer ${apiKey}` }); |
| let body: string | undefined; |
| if (options.body) { |
| headers.set("Content-Type", "application/json"); |
| body = JSON.stringify(options.body); |
| } |
| const response = await fetch(`/v1${path}`, { |
| method: options.method ?? "GET", |
| headers, |
| body, |
| signal: options.signal, |
| }); |
| const responseText = await response.text(); |
| let payload: unknown = null; |
| if (responseText) { |
| try { |
| payload = JSON.parse(responseText); |
| } catch { |
| payload = null; |
| } |
| } |
| if (!response.ok) { |
| const error = readError(payload); |
| const fallback = responseText.trim() || response.statusText || `HTTP ${response.status}`; |
| throw new CreativeApiError(response.status, error.message ?? fallback, error.code); |
| } |
| if (payload === null) throw new CreativeApiError(response.status, "The API returned a non-JSON response", "invalid_response"); |
| return payload; |
| } |
|
|
| async function publicResponsesStream(apiKey: string, body: Record<string, unknown>, onUpdate?: (snapshot: ChatStreamSnapshot) => void, signal?: AbortSignal): Promise<ChatResponseResult> { |
| const response = await fetch("/v1/responses", { |
| method: "POST", |
| headers: new Headers({ Accept: "text/event-stream", Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" }), |
| body: JSON.stringify(body), |
| signal, |
| }); |
| if (!response.ok) { |
| const responseText = await response.text(); |
| const payload = parseJSON(responseText); |
| const error = readError(payload); |
| throw new CreativeApiError(response.status, error.message ?? (responseText.trim() || response.statusText || `HTTP ${response.status}`), error.code); |
| } |
| if (!response.headers.get("content-type")?.includes("text/event-stream")) { |
| const responseText = await response.text(); |
| const payload = parseJSON(responseText); |
| const text = readResponseText(payload); |
| const reasoning = readResponseReasoning(payload); |
| const tools = readResponseTools(payload); |
| if (!text && !reasoning && tools.length === 0) throw new CreativeApiError(response.status, "The Responses API did not return any displayable output", "invalid_response"); |
| return { text, reasoning, tools }; |
| } |
| if (!response.body) throw new CreativeApiError(response.status, "The Responses API stream was empty", "invalid_response"); |
|
|
| const reader = response.body.getReader(); |
| const decoder = new TextDecoder(); |
| let buffer = ""; |
| let text = ""; |
| let reasoning = ""; |
| const tools = new Map<string, ChatToolActivity>(); |
| const snapshot = (): ChatStreamSnapshot => ({ text, reasoning, tools: Array.from(tools.values()) }); |
| const emit = () => onUpdate?.(snapshot()); |
| const applyEnvelope = (payload: unknown) => { |
| const finalText = readResponseText(payload); |
| const finalReasoning = readResponseReasoning(payload); |
| const finalTools = readResponseTools(payload); |
| if (finalText) text = finalText; |
| if (finalReasoning) reasoning = finalReasoning; |
| for (const tool of finalTools) tools.set(tool.id, tool); |
| }; |
| const consume = (block: string) => { |
| const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n"); |
| if (!data || data === "[DONE]") return; |
| const payload = parseJSON(data); |
| if (!isRecord(payload)) return; |
| const type = typeof payload.type === "string" ? payload.type : ""; |
| if (type === "response.output_text.delta" && typeof payload.delta === "string") { |
| text += payload.delta; |
| emit(); |
| return; |
| } |
| if (type === "response.output_text.done" && typeof payload.text === "string") { |
| text = payload.text; |
| emit(); |
| return; |
| } |
| if ((type === "response.reasoning_summary_text.delta" || type === "response.reasoning_text.delta") && typeof payload.delta === "string") { |
| reasoning += payload.delta; |
| emit(); |
| return; |
| } |
| if ((type === "response.reasoning_summary_text.done" || type === "response.reasoning_text.done") && typeof payload.text === "string") { |
| reasoning = payload.text; |
| emit(); |
| return; |
| } |
| if (type === "response.output_item.added" || type === "response.output_item.done") { |
| const item = isRecord(payload.item) ? payload.item : undefined; |
| if (!item) return; |
| if (item.type === "message") { |
| const itemText = readContentText(item.content); |
| if (type === "response.output_item.done" && itemText) text = itemText; |
| } else if (item.type === "reasoning") { |
| const itemReasoning = readReasoningItem(item); |
| if (itemReasoning) reasoning = itemReasoning; |
| } else { |
| const tool = readToolItem(item, type === "response.output_item.done" ? "completed" : "in_progress"); |
| if (tool) tools.set(tool.id, tool); |
| } |
| emit(); |
| return; |
| } |
| if (type === "response.function_call_arguments.delta" || type === "response.custom_tool_call_input.delta") { |
| updateToolDetail(tools, payload, typeof payload.delta === "string" ? payload.delta : "", true); |
| emit(); |
| return; |
| } |
| if (type === "response.function_call_arguments.done" || type === "response.custom_tool_call_input.done") { |
| const detail = typeof payload.arguments === "string" ? payload.arguments : typeof payload.input === "string" ? payload.input : ""; |
| updateToolDetail(tools, payload, detail, false); |
| emit(); |
| return; |
| } |
| if (type === "response.created" || type === "response.in_progress" || type === "response.completed" || type === "response.incomplete") { |
| const responsePayload = isRecord(payload.response) ? payload.response : undefined; |
| if (type === "response.completed" || type === "response.incomplete") { |
| applyEnvelope(responsePayload); |
| emit(); |
| } |
| if (type === "response.incomplete") { |
| throw new CreativeApiError(response.status, readIncompleteReason(responsePayload) || "The response ended before completion", "incomplete_response"); |
| } |
| return; |
| } |
| if (type === "response.failed" || type === "error") { |
| const error = readError(isRecord(payload.response) ? payload.response : payload); |
| throw new CreativeApiError(response.status, error.message ?? "The Responses API stream failed", error.code); |
| } |
| }; |
|
|
| while (true) { |
| const { done, value } = await reader.read(); |
| buffer = (buffer + decoder.decode(value, { stream: !done })).replaceAll("\r\n", "\n"); |
| let boundary = buffer.indexOf("\n\n"); |
| while (boundary >= 0) { |
| consume(buffer.slice(0, boundary)); |
| buffer = buffer.slice(boundary + 2); |
| boundary = buffer.indexOf("\n\n"); |
| } |
| if (done) break; |
| } |
| if (buffer.trim()) consume(buffer); |
| if (!text.trim() && !reasoning.trim() && tools.size === 0) throw new CreativeApiError(response.status, "The Responses API did not return any displayable output", "invalid_response"); |
| return snapshot(); |
| } |
|
|
| function resolveMediaURL(value: string): string { |
| const url = value.trim(); |
| if (!url || url.startsWith("data:") || url.startsWith("blob:")) return url; |
| try { |
| const browserOrigin = typeof window === "undefined" ? "http://localhost" : window.location.origin; |
| const resolved = new URL(url, `${browserOrigin}/`); |
| if (resolved.pathname.startsWith("/v1/media/images/")) { |
| return `${resolved.pathname}${resolved.search}${resolved.hash}`; |
| } |
| return resolved.origin === browserOrigin ? `${resolved.pathname}${resolved.search}${resolved.hash}` : resolved.toString(); |
| } catch { |
| return url; |
| } |
| } |
|
|
| function readVideoRequestID(payload: unknown): string { |
| return isRecord(payload) && typeof payload.request_id === "string" ? payload.request_id.trim() : ""; |
| } |
|
|
| function readResponseText(payload: unknown): string { |
| if (!isRecord(payload)) return ""; |
| if (typeof payload.output_text === "string" && payload.output_text.trim()) return payload.output_text.trim(); |
| if (!Array.isArray(payload.output)) return ""; |
| return payload.output.flatMap((item) => { |
| if (!isRecord(item) || item.type !== "message") return []; |
| return [readContentText(item.content)]; |
| }).filter(Boolean).join("\n").trim(); |
| } |
|
|
| function readResponseReasoning(payload: unknown): string { |
| if (!isRecord(payload) || !Array.isArray(payload.output)) return ""; |
| return payload.output.flatMap((item) => { |
| if (!isRecord(item) || item.type !== "reasoning") return []; |
| return [readReasoningItem(item)]; |
| }).filter(Boolean).join("\n").trim(); |
| } |
|
|
| function readResponseTools(payload: unknown): ChatToolActivity[] { |
| if (!isRecord(payload) || !Array.isArray(payload.output)) return []; |
| return payload.output.flatMap((item) => { |
| if (!isRecord(item) || item.type === "message" || item.type === "reasoning") return []; |
| const tool = readToolItem(item, "completed"); |
| return tool ? [tool] : []; |
| }); |
| } |
|
|
| function readReasoningItem(item: Record<string, unknown>): string { |
| const summary = readContentText(item.summary); |
| return summary || readContentText(item.content); |
| } |
|
|
| function readToolItem(item: Record<string, unknown>, fallbackStatus: ChatToolActivity["status"]): ChatToolActivity | null { |
| const type = typeof item.type === "string" ? item.type.trim() : ""; |
| if (!type) return null; |
| const id = firstString(item.id, item.call_id) || `${type}-${firstString(item.name) || "tool"}`; |
| const name = firstString(item.name) || toolNameFromType(type); |
| const action = isRecord(item.action) ? item.action : undefined; |
| const detail = firstString(item.arguments, item.input, action?.query, item.query); |
| return { id, type, name, status: readToolStatus(item.status, fallbackStatus), detail }; |
| } |
|
|
| function updateToolDetail(tools: Map<string, ChatToolActivity>, payload: Record<string, unknown>, detail: string, append: boolean): void { |
| const id = firstString(payload.item_id, payload.call_id); |
| if (!id) return; |
| const current = tools.get(id) ?? { id, type: "function_call", name: "tool", status: "in_progress" as const, detail: "" }; |
| tools.set(id, { ...current, detail: append ? current.detail + detail : detail || current.detail }); |
| } |
|
|
| function readToolStatus(value: unknown, fallback: ChatToolActivity["status"]): ChatToolActivity["status"] { |
| if (value === "completed") return "completed"; |
| if (value === "failed" || value === "incomplete") return "failed"; |
| if (value === "in_progress" || value === "searching") return "in_progress"; |
| return fallback; |
| } |
|
|
| function toolNameFromType(type: string): string { |
| if (type === "web_search_call" || type === "web_search") return "web_search"; |
| if (type === "x_search_call" || type === "x_search") return "x_search"; |
| return type.replace(/_call$/, ""); |
| } |
|
|
| function readIncompleteReason(payload: unknown): string { |
| if (!isRecord(payload) || !isRecord(payload.incomplete_details)) return ""; |
| const reason = firstString(payload.incomplete_details.reason); |
| return reason ? `The response was incomplete: ${reason}` : ""; |
| } |
|
|
| function firstString(...values: unknown[]): string { |
| for (const value of values) { |
| if (typeof value === "string" && value.trim()) return value.trim(); |
| } |
| return ""; |
| } |
|
|
| function readContentText(content: unknown): string { |
| if (typeof content === "string") return content.trim(); |
| if (!Array.isArray(content)) return ""; |
| return content.map((item) => { |
| if (typeof item === "string") return item; |
| if (!isRecord(item)) return ""; |
| return typeof item.text === "string" ? item.text : typeof item.content === "string" ? item.content : ""; |
| }).filter(Boolean).join("\n").trim(); |
| } |
|
|
| function readImages(payload: unknown): ImageResult[] { |
| if (!isRecord(payload) || !Array.isArray(payload.data)) return []; |
| return payload.data.flatMap((item) => { |
| if (!isRecord(item)) return []; |
| const url = typeof item.url === "string" && item.url.trim() |
| ? item.url |
| : typeof item.b64_json === "string" && item.b64_json.trim() |
| ? `data:image/png;base64,${item.b64_json}` |
| : ""; |
| return url ? [{ url, revisedPrompt: typeof item.revised_prompt === "string" ? item.revised_prompt : undefined }] : []; |
| }); |
| } |
|
|
| function readVideoStatus(payload: unknown): VideoStatus { |
| if (!isRecord(payload) || !isVideoStatus(payload.status)) { |
| throw new CreativeApiError(200, "The video status response was invalid", "invalid_response"); |
| } |
| const result: VideoStatus = { |
| status: payload.status, |
| model: typeof payload.model === "string" ? payload.model : undefined, |
| progress: typeof payload.progress === "number" && Number.isFinite(payload.progress) |
| ? Math.max(0, Math.min(100, payload.progress)) |
| : payload.status === "done" ? 100 : 0, |
| }; |
| if (isRecord(payload.video) && typeof payload.video.url === "string") { |
| result.video = { |
| url: payload.video.url, |
| duration: typeof payload.video.duration === "number" ? payload.video.duration : undefined, |
| respectModeration: typeof payload.video.respect_moderation === "boolean" ? payload.video.respect_moderation : undefined, |
| }; |
| } |
| if (isRecord(payload.error) && typeof payload.error.message === "string") { |
| result.error = { |
| code: typeof payload.error.code === "string" ? payload.error.code : undefined, |
| message: payload.error.message, |
| }; |
| } |
| return result; |
| } |
|
|
| function readError(payload: unknown): { code?: string; message?: string } { |
| if (!isRecord(payload)) return {}; |
| const error = isRecord(payload.error) ? payload.error : payload; |
| return { |
| code: typeof error.code === "string" ? error.code : undefined, |
| message: typeof error.message === "string" ? error.message : undefined, |
| }; |
| } |
|
|
| function parseJSON(value: string): unknown { |
| if (!value.trim()) return null; |
| try { |
| return JSON.parse(value); |
| } catch { |
| return null; |
| } |
| } |
|
|
| function isVideoStatus(value: unknown): value is VideoStatus["status"] { |
| return value === "pending" || value === "done" || value === "failed"; |
| } |
|
|
| function isRecord(value: unknown): value is Record<string, unknown> { |
| return typeof value === "object" && value !== null && !Array.isArray(value); |
| } |
|
|
