@axiastudio/aioc 0.1.0-alpha.0

package/dist/providers/chat-completions.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompletionsProvider = void 0;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+function toJsonSchema(schema) {
+    const convert = zod_to_json_schema_1.zodToJsonSchema;
+    return convert(schema, { $refStrategy: "none" });
+}
+function stringifySafe(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return "{}";
+    }
+}
+function normalizeContentPart(part) {
+    if (!part || typeof part !== "object") {
+        return null;
+    }
+    const record = part;
+    const partType = typeof record.type === "string" ? record.type : "";
+    if ((partType === "input_text" ||
+        partType === "output_text" ||
+        partType === "text") &&
+        typeof record.text === "string") {
+        return {
+            type: "text",
+            text: record.text,
+        };
+    }
+    if (partType === "image_url" ||
+        partType === "input_audio" ||
+        partType === "refusal" ||
+        partType === "audio" ||
+        partType === "file") {
+        return record;
+    }
+    if (typeof record.text === "string") {
+        return {
+            type: "text",
+            text: record.text,
+        };
+    }
+    return null;
+}
+function normalizeMessageContent(content) {
+    if (content === null || typeof content === "undefined") {
+        return null;
+    }
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const normalizedParts = content
+            .map((part) => normalizeContentPart(part))
+            .filter((part) => Boolean(part));
+        if (normalizedParts.length > 0) {
+            return normalizedParts;
+        }
+        return stringifySafe(content);
+    }
+    const singlePart = normalizeContentPart(content);
+    if (singlePart) {
+        return [singlePart];
+    }
+    return stringifySafe(content);
+}
+function toChatMessages(items, systemPrompt) {
+    const messages = [];
+    if (systemPrompt) {
+        messages.push({
+            role: "system",
+            content: systemPrompt,
+        });
+    }
+    for (const item of items) {
+        if (item.type === "message") {
+            messages.push({
+                role: item.role,
+                content: normalizeMessageContent(item.content),
+            });
+            continue;
+        }
+        if (item.type === "tool_call_item") {
+            messages.push({
+                role: "assistant",
+                content: null,
+                tool_calls: [
+                    {
+                        id: item.callId,
+                        type: "function",
+                        function: {
+                            name: item.name,
+                            arguments: stringifySafe(item.arguments),
+                        },
+                    },
+                ],
+            });
+            continue;
+        }
+        if (item.type === "tool_call_output_item") {
+            messages.push({
+                role: "tool",
+                tool_call_id: item.callId,
+                content: stringifySafe(item.output),
+            });
+        }
+    }
+    return messages;
+}
+function toModelSettings(modelSettings) {
+    if (!modelSettings) {
+        return {};
+    }
+    const allowed = [
+        "temperature",
+        "top_p",
+        "max_tokens",
+        "presence_penalty",
+        "frequency_penalty",
+        "seed",
+        "parallel_tool_calls",
+    ];
+    const parsed = {};
+    for (const key of allowed) {
+        if (typeof modelSettings[key] !== "undefined") {
+            parsed[key] = modelSettings[key];
+        }
+    }
+    return parsed;
+}
+function toTools(tools) {
+    return tools.map((definition) => {
+        const rawSchema = toJsonSchema(definition.parameters);
+        const schema = { ...rawSchema };
+        delete schema.$schema;
+        return {
+            type: "function",
+            function: {
+                name: definition.name,
+                description: definition.description,
+                parameters: schema,
+            },
+        };
+    });
+}
+function buildHeaders(options) {
+    const headers = {
+        Authorization: `Bearer ${options.apiKey}`,
+        "Content-Type": "application/json",
+        ...(options.headers ?? {}),
+    };
+    return headers;
+}
+function normalizeBaseURL(baseURL) {
+    return baseURL.replace(/\/+$/, "");
+}
+async function* parseSseEvents(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        let separatorIndex = buffer.indexOf("\n\n");
+        while (separatorIndex !== -1) {
+            const rawEvent = buffer.slice(0, separatorIndex);
+            buffer = buffer.slice(separatorIndex + 2);
+            const payloadLines = rawEvent
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line.startsWith("data:"))
+                .map((line) => line.replace(/^data:\s?/, ""));
+            if (payloadLines.length > 0) {
+                yield payloadLines.join("\n");
+            }
+            separatorIndex = buffer.indexOf("\n\n");
+        }
+    }
+    const finalChunk = decoder.decode();
+    if (finalChunk) {
+        buffer += finalChunk;
+    }
+    const remaining = buffer.trim();
+    if (!remaining) {
+        return;
+    }
+    const payloadLines = remaining
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.replace(/^data:\s?/, ""));
+    if (payloadLines.length > 0) {
+        yield payloadLines.join("\n");
+    }
+}
+class ChatCompletionsProvider {
+    baseURL;
+    headers;
+    constructor(options) {
+        this.baseURL = normalizeBaseURL(options.baseURL);
+        this.headers = buildHeaders(options);
+    }
+    async *stream(request) {
+        const payload = {
+            model: request.model,
+            messages: toChatMessages(request.messages, request.systemPrompt),
+            tools: request.tools.length > 0 ? toTools(request.tools) : undefined,
+            tool_choice: request.tools.length > 0 ? "auto" : undefined,
+            stream: true,
+            ...toModelSettings(request.modelSettings),
+        };
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const details = await response.text().catch(() => "");
+            throw new Error(`Chat completions request failed (${response.status}): ${details || response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error("Chat completions response has no stream body.");
+        }
+        const pendingToolCalls = new Map();
+        let outputText = "";
+        let completed = false;
+        for await (const rawEvent of parseSseEvents(response.body)) {
+            if (rawEvent === "[DONE]") {
+                continue;
+            }
+            let chunk;
+            try {
+                chunk = JSON.parse(rawEvent);
+            }
+            catch {
+                continue;
+            }
+            const choice = chunk.choices?.[0];
+            if (!choice) {
+                continue;
+            }
+            if (typeof choice.delta?.content === "string") {
+                outputText += choice.delta.content;
+                yield {
+                    type: "delta",
+                    delta: choice.delta.content,
+                };
+            }
+            if (choice.delta?.tool_calls) {
+                for (const partialCall of choice.delta.tool_calls) {
+                    const index = partialCall.index ?? 0;
+                    const existing = pendingToolCalls.get(index) ?? {
+                        id: `call_${index}`,
+                        name: "",
+                        arguments: "",
+                    };
+                    if (partialCall.id) {
+                        existing.id = partialCall.id;
+                    }
+                    if (partialCall.function?.name) {
+                        existing.name = partialCall.function.name;
+                    }
+                    if (partialCall.function?.arguments) {
+                        existing.arguments += partialCall.function.arguments;
+                    }
+                    pendingToolCalls.set(index, existing);
+                }
+            }
+            if (choice.finish_reason && !completed) {
+                completed = true;
+                if (choice.finish_reason === "tool_calls") {
+                    for (const call of pendingToolCalls.values()) {
+                        yield {
+                            type: "tool_call",
+                            callId: call.id,
+                            name: call.name,
+                            arguments: call.arguments || "{}",
+                        };
+                    }
+                }
+                yield {
+                    type: "completed",
+                    message: outputText,
+                    finishReason: choice.finish_reason,
+                };
+            }
+        }
+        if (!completed) {
+            if (pendingToolCalls.size > 0) {
+                for (const call of pendingToolCalls.values()) {
+                    yield {
+                        type: "tool_call",
+                        callId: call.id,
+                        name: call.name,
+                        arguments: call.arguments || "{}",
+                    };
+                }
+            }
+            yield {
+                type: "completed",
+                message: outputText,
+            };
+        }
+    }
+}
+exports.ChatCompletionsProvider = ChatCompletionsProvider;

package/dist/providers/mistral.d.ts

@@ -0,0 +1,8 @@
+import { ChatCompletionsProvider, ChatCompletionsProviderOptions } from "./chat-completions";
+export type MistralProviderOptions = Omit<ChatCompletionsProviderOptions, "baseURL"> & {
+    baseURL?: string;
+};
+export declare class MistralProvider extends ChatCompletionsProvider {
+    constructor(options: MistralProviderOptions);
+}
+//# sourceMappingURL=mistral.d.ts.map

package/dist/providers/mistral.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mistral.d.ts","sourceRoot":"","sources":["../../src/providers/mistral.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC/B,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,8BAA8B,EAC9B,SAAS,CACV,GAAG;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,qBAAa,eAAgB,SAAQ,uBAAuB;gBAC9C,OAAO,EAAE,sBAAsB;CAO5C"}

package/dist/providers/mistral.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MistralProvider = void 0;
+const chat_completions_1 = require("./chat-completions");
+class MistralProvider extends chat_completions_1.ChatCompletionsProvider {
+    constructor(options) {
+        super({
+            apiKey: options.apiKey,
+            baseURL: options.baseURL ?? "https://api.mistral.ai/v1",
+            headers: options.headers,
+        });
+    }
+}
+exports.MistralProvider = MistralProvider;

package/dist/providers/openai.d.ts

@@ -0,0 +1,11 @@
+import { ChatCompletionsProvider, ChatCompletionsProviderOptions } from "./chat-completions";
+export type OpenAIProviderOptions = Omit<ChatCompletionsProviderOptions, "baseURL" | "headers"> & {
+    baseURL?: string;
+    organization?: string;
+    project?: string;
+    headers?: Record<string, string>;
+};
+export declare class OpenAIProvider extends ChatCompletionsProvider {
+    constructor(options: OpenAIProviderOptions);
+}
+//# sourceMappingURL=openai.d.ts.map

package/dist/providers/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../src/providers/openai.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC/B,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,qBAAqB,GAAG,IAAI,CACtC,8BAA8B,EAC9B,SAAS,GAAG,SAAS,CACtB,GAAG;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAcF,qBAAa,cAAe,SAAQ,uBAAuB;gBAC7C,OAAO,EAAE,qBAAqB;CAO3C"}

package/dist/providers/openai.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const chat_completions_1 = require("./chat-completions");
+function toOpenAIHeaders(options) {
+    return {
+        ...(options.headers ?? {}),
+        ...(options.organization
+            ? { "OpenAI-Organization": options.organization }
+            : {}),
+        ...(options.project ? { "OpenAI-Project": options.project } : {}),
+    };
+}
+class OpenAIProvider extends chat_completions_1.ChatCompletionsProvider {
+    constructor(options) {
+        super({
+            apiKey: options.apiKey,
+            baseURL: options.baseURL ?? "https://api.openai.com/v1",
+            headers: toOpenAIHeaders(options),
+        });
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

package/dist/run-context.d.ts

@@ -0,0 +1,5 @@
+export declare class RunContext<TContext = unknown> {
+    context: TContext;
+    constructor(context: TContext);
+}
+//# sourceMappingURL=run-context.d.ts.map

package/dist/run-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-context.d.ts","sourceRoot":"","sources":["../src/run-context.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAU,CAAC,QAAQ,GAAG,OAAO;IACxC,OAAO,EAAE,QAAQ,CAAC;gBAEN,OAAO,EAAE,QAAQ;CAG9B"}

package/dist/run-context.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunContext = void 0;
+class RunContext {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+}
+exports.RunContext = RunContext;

package/dist/run-log-emitter.d.ts

@@ -0,0 +1,21 @@
+import type { RunLogger } from "./logger";
+export declare class RunLogEmitter {
+    private logger?;
+    constructor(logger?: RunLogger);
+    private createTimestamp;
+    private emit;
+    runStarted(agent: string, maxTurns: number, historyItems: number): Promise<void>;
+    agentActivated(agent: string, turn: number): Promise<void>;
+    turnStarted(agent: string, turn: number): Promise<void>;
+    toolCallStarted(agent: string, turn: number, toolName: string, callId: string): Promise<void>;
+    toolPolicyEvaluated(agent: string, turn: number, toolName: string, callId: string, decision: "allow" | "deny", reason: string, policyVersion?: string, metadata?: Record<string, unknown>): Promise<void>;
+    handoffPolicyEvaluated(agent: string, turn: number, handoffName: string, callId: string, toAgent: string, decision: "allow" | "deny", reason: string, policyVersion?: string, metadata?: Record<string, unknown>): Promise<void>;
+    toolCallCompleted(agent: string, turn: number, toolName: string, callId: string): Promise<void>;
+    toolCallFailed(agent: string, turn: number, toolName: string, callId: string, error: unknown): Promise<void>;
+    outputGuardrailStarted(agent: string, turn: number, guardrailName: string): Promise<void>;
+    outputGuardrailPassed(agent: string, turn: number, guardrailName: string): Promise<void>;
+    outputGuardrailTriggered(agent: string, turn: number, guardrailName: string, reason?: string): Promise<void>;
+    runCompleted(agent: string, turn: number, outputLength: number): Promise<void>;
+    runFailed(agent: string, turn: number | undefined, error: unknown): Promise<void>;
+}
+//# sourceMappingURL=run-log-emitter.d.ts.map

package/dist/run-log-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-log-emitter.d.ts","sourceRoot":"","sources":["../src/run-log-emitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,SAAS,EAAE,MAAM,UAAU,CAAC;AAmBvD,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,CAAY;gBAEf,MAAM,CAAC,EAAE,SAAS;IAI9B,OAAO,CAAC,eAAe;YAIT,IAAI;IAYZ,UAAU,CACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC;IAWV,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU1D,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUvD,eAAe,CACnB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAYV,mBAAmB,CACvB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,GAAG,MAAM,EAC1B,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;IAgBV,sBAAsB,CAC1B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,OAAO,GAAG,MAAM,EAC1B,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;IAiBV,iBAAiB,CACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAYV,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,IAAI,CAAC;IAeV,sBAAsB,CAC1B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC;IAWV,qBAAqB,CACzB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC;IAWV,wBAAwB,CAC5B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC;IAYV,YAAY,CAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC;IAWV,SAAS,CACb,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,IAAI,CAAC;CAYjB"}

package/dist/run-log-emitter.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunLogEmitter = void 0;
+function toErrorDetails(error) {
+    if (error instanceof Error) {
+        return {
+            errorName: error.name,
+            errorMessage: error.message,
+        };
+    }
+    return {
+        errorName: "Error",
+        errorMessage: String(error),
+    };
+}
+class RunLogEmitter {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    createTimestamp() {
+        return new Date().toISOString();
+    }
+    async emit(event) {
+        if (!this.logger) {
+            return;
+        }
+        try {
+            await this.logger.log(event);
+        }
+        catch {
+            // Logging must never break runtime behavior.
+        }
+    }
+    async runStarted(agent, maxTurns, historyItems) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "info",
+            type: "run_started",
+            agent,
+            maxTurns,
+            historyItems,
+        });
+    }
+    async agentActivated(agent, turn) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "info",
+            type: "agent_activated",
+            agent,
+            turn,
+        });
+    }
+    async turnStarted(agent, turn) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "debug",
+            type: "turn_started",
+            agent,
+            turn,
+        });
+    }
+    async toolCallStarted(agent, turn, toolName, callId) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "info",
+            type: "tool_call_started",
+            agent,
+            turn,
+            toolName,
+            callId,
+        });
+    }
+    async toolPolicyEvaluated(agent, turn, toolName, callId, decision, reason, policyVersion, metadata) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: decision === "deny" ? "warn" : "info",
+            type: "tool_policy_evaluated",
+            agent,
+            turn,
+            toolName,
+            callId,
+            decision,
+            reason,
+            policyVersion,
+            metadata,
+        });
+    }
+    async handoffPolicyEvaluated(agent, turn, handoffName, callId, toAgent, decision, reason, policyVersion, metadata) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: decision === "deny" ? "warn" : "info",
+            type: "handoff_policy_evaluated",
+            agent,
+            turn,
+            handoffName,
+            callId,
+            toAgent,
+            decision,
+            reason,
+            policyVersion,
+            metadata,
+        });
+    }
+    async toolCallCompleted(agent, turn, toolName, callId) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "info",
+            type: "tool_call_completed",
+            agent,
+            turn,
+            toolName,
+            callId,
+        });
+    }
+    async toolCallFailed(agent, turn, toolName, callId, error) {
+        const details = toErrorDetails(error);
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "error",
+            type: "tool_call_failed",
+            agent,
+            turn,
+            toolName,
+            callId,
+            errorName: details.errorName,
+            errorMessage: details.errorMessage,
+        });
+    }
+    async outputGuardrailStarted(agent, turn, guardrailName) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "debug",
+            type: "output_guardrail_started",
+            agent,
+            turn,
+            guardrailName,
+        });
+    }
+    async outputGuardrailPassed(agent, turn, guardrailName) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "info",
+            type: "output_guardrail_passed",
+            agent,
+            turn,
+            guardrailName,
+        });
+    }
+    async outputGuardrailTriggered(agent, turn, guardrailName, reason) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "warn",
+            type: "output_guardrail_triggered",
+            agent,
+            turn,
+            guardrailName,
+            reason,
+        });
+    }
+    async runCompleted(agent, turn, outputLength) {
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "info",
+            type: "run_completed",
+            agent,
+            turn,
+            outputLength,
+        });
+    }
+    async runFailed(agent, turn, error) {
+        const details = toErrorDetails(error);
+        await this.emit({
+            timestamp: this.createTimestamp(),
+            level: "error",
+            type: "run_failed",
+            agent,
+            turn,
+            errorName: details.errorName,
+            errorMessage: details.errorMessage,
+        });
+    }
+}
+exports.RunLogEmitter = RunLogEmitter;

package/dist/run-record.d.ts

@@ -0,0 +1,61 @@
+import type { AgentInputItem } from "./types";
+export type RunRecordStatus = "completed" | "failed";
+export interface PolicyResourceSnapshot {
+    kind: "tool" | "handoff";
+    name: string;
+    action?: string;
+    resourceId?: string;
+}
+export interface PolicyDecisionRecord {
+    timestamp: string;
+    turn: number;
+    callId: string;
+    decision: "allow" | "deny";
+    reason: string;
+    policyVersion?: string;
+    resource: PolicyResourceSnapshot;
+    metadata?: Record<string, unknown>;
+}
+export interface GuardrailDecisionRecord {
+    timestamp: string;
+    turn: number;
+    guardrailName: string;
+    decision: "pass" | "triggered";
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RunRecord<TContext = unknown> {
+    runId: string;
+    startedAt: string;
+    completedAt: string;
+    status: RunRecordStatus;
+    agentName: string;
+    providerName?: string;
+    model?: string;
+    question: string;
+    response: string;
+    contextSnapshot: TContext;
+    contextRedacted?: boolean;
+    items: AgentInputItem[];
+    policyDecisions: PolicyDecisionRecord[];
+    guardrailDecisions?: GuardrailDecisionRecord[];
+    errorName?: string;
+    errorMessage?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RunRecordContextRedactionResult<TContext = unknown> {
+    contextSnapshot: TContext;
+    contextRedacted: boolean;
+}
+export type RunRecordContextRedactor<TContext = unknown> = (context: TContext) => RunRecordContextRedactionResult<TContext> | Promise<RunRecordContextRedactionResult<TContext>>;
+export type RunRecordWriter<TContext = unknown> = (record: RunRecord<TContext>) => Promise<void> | void;
+export interface RunRecordSink<TContext = unknown> {
+    write: RunRecordWriter<TContext>;
+}
+export interface RunRecordOptions<TContext = unknown> {
+    runId?: string;
+    metadata?: Record<string, unknown>;
+    contextRedactor?: RunRecordContextRedactor<TContext>;
+    sink?: RunRecordSink<TContext> | RunRecordWriter<TContext>;
+}
+//# sourceMappingURL=run-record.d.ts.map

package/dist/run-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-record.d.ts","sourceRoot":"","sources":["../src/run-record.ts"],"names":[],"mappings":"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"}

package/dist/run-record.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });