@alpacakit/agents 0.1.0-beta.19

package/dist/agents/openai-compatible/pi/session.js

@@ -0,0 +1,354 @@
+import path from "node:path";
+import { AsyncQueue } from "../../../core/async-queue.js";
+import { AGENT_EVENT_TYPE, } from "../../../core/run.js";
+import { piSandboxToolPolicy } from "./sandbox.js";
+const PI_PROVIDER_API = "openai-completions";
+const PI_PROVIDER_API_KEY_PLACEHOLDER = "unused";
+const PI_PROVIDER_TEXT_INPUT = "text";
+const PI_PROVIDER_ZERO_COST = 0;
+const PI_HEADER = {
+    authorizationLowercase: "authorization",
+    authorization: "Authorization",
+};
+const PI_RESOURCE_DIRECTORY = {
+    agents: ".agents",
+    skills: "skills",
+};
+/**
+ * Session event names, verified against the subscribed union
+ * (`@earendil-works/pi-agent-core` 0.75.5, `dist/types.d.ts` `AgentEvent`).
+ * Pi emits lifecycle groups — `turn_start`/`turn_end`,
+ * `message_start`/`message_update`/`message_end`,
+ * `tool_execution_start`/`_update`/`_end` — and the kernel guards count
+ * `turn`/`tool` kernel events, so each group must map to exactly ONE
+ * kernel event or the guard caps fire early. Every unmapped pi event
+ * flows through as `trace`.
+ */
+const PI_SESSION_EVENT_TYPE = {
+    turnEnd: "turn_end",
+    toolExecutionStart: "tool_execution_start",
+    messageEnd: "message_end",
+};
+const PI_EVENT_FIELD = {
+    type: "type",
+    toolName: "toolName",
+    message: "message",
+    role: "role",
+    content: "content",
+    text: "text",
+};
+const PI_CONTENT_BLOCK_TYPE = {
+    text: "text",
+};
+const PI_ROLE = {
+    assistant: "assistant",
+};
+const EMPTY_TEXT = "";
+const STREAMED_MESSAGE_SEPARATOR = "\n";
+export function runPiSession(input) {
+    return new PiSessionRun(input).run();
+}
+class PiSessionRun {
+    input;
+    queue = new AsyncQueue();
+    streamedMessages = [];
+    session = null;
+    unsubscribe = null;
+    promptError = null;
+    disposeCalled = false;
+    constructor(input) {
+        this.input = input;
+    }
+    async *run() {
+        const session = await this.createSession();
+        this.session = session;
+        const removeAbortListener = installAbortListener(this.input.ctx.signal, () => this.abort());
+        try {
+            await session.bindExtensions({});
+            applyRequestParamsPayloadOverride(session, this.input.config.requestParams);
+            this.unsubscribe =
+                session.subscribe?.((event) => this.acceptEvent(event)) ?? null;
+            const promptDone = this.prompt(session);
+            for await (const event of this.queue) {
+                yield event;
+            }
+            if (this.input.ctx.signal.aborted) {
+                return this.outcome(this.streamedText());
+            }
+            await promptDone;
+            if (this.promptError !== null) {
+                throw this.promptError;
+            }
+            return this.outcome(this.assistantText(session));
+        }
+        finally {
+            removeAbortListener();
+            this.unsubscribe?.();
+            this.dispose();
+        }
+    }
+    async createSession() {
+        const authStorage = this.input.module.AuthStorage.inMemory();
+        if (this.input.config.apiKey !== null) {
+            authStorage.setRuntimeApiKey(this.input.config.id, this.input.config.apiKey);
+        }
+        const modelRegistry = this.input.module.ModelRegistry.inMemory(authStorage);
+        modelRegistry.registerProvider(this.input.config.id, providerConfig(this.input));
+        const model = modelRegistry.find(this.input.config.id, this.input.config.model);
+        const settingsManager = this.input.module.SettingsManager.inMemory();
+        const resourceLoader = new this.input.module.DefaultResourceLoader({
+            cwd: this.input.options.workspace,
+            agentDir: this.input.agentDir,
+            settingsManager,
+            additionalSkillPaths: piSkillPaths(this.input.options.workspace, this.input.agentDir),
+        });
+        await resourceLoader.reload();
+        const policy = piSandboxToolPolicy(this.input.options.sandbox, {
+            module: this.input.module,
+            workspace: this.input.options.workspace,
+        });
+        const created = await this.input.module.createAgentSession({
+            cwd: this.input.options.workspace,
+            agentDir: this.input.agentDir,
+            authStorage,
+            modelRegistry,
+            model,
+            resourceLoader,
+            sessionManager: this.input.module.SessionManager.inMemory(this.input.options.workspace),
+            settingsManager,
+            ...policy,
+        });
+        return created.session;
+    }
+    prompt(session) {
+        return Promise.resolve()
+            .then(() => session.prompt(this.input.options.prompt))
+            .then(() => this.queue.end(), (error) => {
+            this.promptError = error;
+            this.queue.end();
+        });
+    }
+    acceptEvent(event) {
+        const projection = piEventProjection(event);
+        if (projection.assistantText !== null) {
+            this.streamedMessages.push(projection.assistantText);
+        }
+        for (const mapped of projection.events) {
+            this.queue.push(mapped);
+        }
+    }
+    abort() {
+        const session = this.session;
+        if (session === null) {
+            this.queue.end();
+            return;
+        }
+        const aborting = session.abort?.();
+        if (aborting === undefined) {
+            this.queue.end();
+            return;
+        }
+        void aborting.then(() => this.queue.end(), () => this.queue.end());
+    }
+    dispose() {
+        if (this.disposeCalled || this.session === null) {
+            return;
+        }
+        this.disposeCalled = true;
+        this.session.dispose();
+    }
+    streamedText() {
+        return this.streamedMessages.join(STREAMED_MESSAGE_SEPARATOR);
+    }
+    assistantText(session) {
+        return this.streamedMessages.length === 0
+            ? lastAssistantText(session)
+            : this.streamedText();
+    }
+    outcome(text) {
+        return {
+            text,
+            model: this.input.config.model,
+            exit: null,
+            raw: null,
+            usage: null,
+        };
+    }
+}
+function installAbortListener(signal, abort) {
+    if (signal.aborted) {
+        abort();
+        return () => { };
+    }
+    signal.addEventListener("abort", abort, { once: true });
+    return () => signal.removeEventListener("abort", abort);
+}
+function providerConfig(input) {
+    const config = input.config;
+    const headers = providerHeaders(config);
+    return {
+        name: config.id,
+        baseUrl: config.baseUrl,
+        apiKey: PI_PROVIDER_API_KEY_PLACEHOLDER,
+        api: PI_PROVIDER_API,
+        authHeader: config.apiKey !== null && !hasHeader(config.headers),
+        ...(Object.keys(headers).length === 0 ? {} : { headers }),
+        models: [
+            {
+                id: config.model,
+                name: config.model,
+                api: PI_PROVIDER_API,
+                reasoning: false,
+                input: [PI_PROVIDER_TEXT_INPUT],
+                cost: {
+                    input: PI_PROVIDER_ZERO_COST,
+                    output: PI_PROVIDER_ZERO_COST,
+                    cacheRead: PI_PROVIDER_ZERO_COST,
+                    cacheWrite: PI_PROVIDER_ZERO_COST,
+                },
+                contextWindow: input.contextWindow,
+                maxTokens: input.maxTokens,
+            },
+        ],
+    };
+}
+/**
+ * Constraint: pi's openai-completions transport constructs its HTTP client
+ * with SOME api key (our placeholder "unused") and that client sends
+ * `Authorization: Bearer <apiKey>` unless an explicit Authorization header
+ * overrides it. For keyless endpoints with no caller Authorization header
+ * we therefore register an explicit EMPTY Authorization header so the
+ * placeholder key never reaches the wire.
+ */
+function providerHeaders(config) {
+    if (config.apiKey !== null || hasHeader(config.headers)) {
+        return { ...config.headers };
+    }
+    return { ...config.headers, [PI_HEADER.authorization]: EMPTY_TEXT };
+}
+function hasHeader(headers) {
+    return Object.keys(headers).some((name) => name.toLowerCase() === PI_HEADER.authorizationLowercase);
+}
+function piSkillPaths(workspace, agentDir) {
+    return [
+        path.join(workspace, PI_RESOURCE_DIRECTORY.agents, PI_RESOURCE_DIRECTORY.skills),
+        path.join(workspace, PI_RESOURCE_DIRECTORY.skills),
+        path.join(agentDir, PI_RESOURCE_DIRECTORY.skills),
+    ];
+}
+function applyRequestParamsPayloadOverride(session, requestParams) {
+    if (Object.keys(requestParams).length === 0 || session.agent === undefined) {
+        return;
+    }
+    const previousOnPayload = session.agent.onPayload;
+    session.agent.onPayload = async (payload, model) => {
+        const previousPayload = await previousOnPayload?.(payload, model);
+        const basePayload = previousPayload === undefined ? payload : previousPayload;
+        return {
+            ...(isObjectRecord(basePayload) ? basePayload : {}),
+            ...requestParams,
+        };
+    };
+}
+/** One row per mapped pi event type; anything else projects to `trace`. */
+const PI_SESSION_EVENT_PROJECTORS = {
+    [PI_SESSION_EVENT_TYPE.turnEnd]: () => ({
+        events: [{ type: AGENT_EVENT_TYPE.turn }],
+        assistantText: null,
+    }),
+    [PI_SESSION_EVENT_TYPE.toolExecutionStart]: projectToolExecutionStart,
+    [PI_SESSION_EVENT_TYPE.messageEnd]: projectMessageEnd,
+};
+function piEventProjection(event) {
+    if (!isObjectRecord(event)) {
+        return traceProjection(event);
+    }
+    const type = readStringField(event, PI_EVENT_FIELD.type);
+    if (type === null || !isPiSessionEventType(type)) {
+        return traceProjection(event);
+    }
+    return PI_SESSION_EVENT_PROJECTORS[type](event) ?? traceProjection(event);
+}
+function isPiSessionEventType(type) {
+    return Object.values(PI_SESSION_EVENT_TYPE).includes(type);
+}
+function projectToolExecutionStart(event) {
+    const toolName = readStringField(event, PI_EVENT_FIELD.toolName);
+    return toolName === null
+        ? null
+        : {
+            events: [{ type: AGENT_EVENT_TYPE.tool, name: toolName }],
+            assistantText: null,
+        };
+}
+function projectMessageEnd(event) {
+    const text = assistantMessageText(event[PI_EVENT_FIELD.message]);
+    return text === null
+        ? null
+        : {
+            events: [{ type: AGENT_EVENT_TYPE.message, text }],
+            assistantText: text,
+        };
+}
+function traceProjection(data) {
+    return {
+        events: [{ type: AGENT_EVENT_TYPE.trace, data }],
+        assistantText: null,
+    };
+}
+/**
+ * Extracts the text of a pi `AgentMessage` when it is an assistant
+ * message: `{ role: "assistant", content: (TextContent | ...)[] }` with
+ * text blocks `{ type: "text", text }` (pi-ai 0.75.5). A plain string
+ * `content` is accepted as already-joined text. `null` = not an assistant
+ * text message.
+ */
+function assistantMessageText(message) {
+    if (!isObjectRecord(message)) {
+        return null;
+    }
+    if (readStringField(message, PI_EVENT_FIELD.role) !== PI_ROLE.assistant) {
+        return null;
+    }
+    const content = message[PI_EVENT_FIELD.content];
+    if (typeof content === "string") {
+        return content === EMPTY_TEXT ? null : content;
+    }
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const text = content
+        .map((block) => textBlockText(block))
+        .filter((blockText) => blockText !== null)
+        .join(EMPTY_TEXT);
+    return text === EMPTY_TEXT ? null : text;
+}
+function textBlockText(block) {
+    if (!isObjectRecord(block)) {
+        return null;
+    }
+    if (readStringField(block, PI_EVENT_FIELD.type) !== PI_CONTENT_BLOCK_TYPE.text) {
+        return null;
+    }
+    return readStringField(block, PI_EVENT_FIELD.text);
+}
+function lastAssistantText(session) {
+    const messages = session.state?.messages;
+    if (!Array.isArray(messages)) {
+        return EMPTY_TEXT;
+    }
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const text = assistantMessageText(messages[index]);
+        if (text !== null) {
+            return text;
+        }
+    }
+    return EMPTY_TEXT;
+}
+function readStringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : null;
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/agents/openai-compatible/response.d.ts

@@ -0,0 +1,19 @@
+import type { AgentRunOutcome } from "../../core/run.js";
+import { type AgentEvent } from "../../core/run.js";
+export interface OpenAiCompatibleResponseDecoder {
+    readonly id: string;
+    supports(response: Response): boolean;
+    decode(response: Response, model: string): AsyncGenerator<AgentEvent, AgentRunOutcome, void>;
+}
+export declare class EventStreamOpenAiCompatibleResponseDecoder implements OpenAiCompatibleResponseDecoder {
+    readonly id: "event-stream";
+    supports(response: Response): boolean;
+    decode(response: Response, model: string): AsyncGenerator<AgentEvent, AgentRunOutcome, void>;
+}
+export declare class JsonOpenAiCompatibleResponseDecoder implements OpenAiCompatibleResponseDecoder {
+    readonly id: "json";
+    supports(response: Response): boolean;
+    decode(response: Response, model: string): AsyncGenerator<AgentEvent, AgentRunOutcome, void>;
+}
+export declare function createDefaultOpenAiCompatibleResponseDecoders(): readonly OpenAiCompatibleResponseDecoder[];
+//# sourceMappingURL=response.d.ts.map

package/dist/agents/openai-compatible/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/agents/openai-compatible/response.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA0BtE,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC;IACtC,MAAM,CACJ,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GACZ,cAAc,CAAC,UAAU,EAAE,eAAe,EAAE,IAAI,CAAC,CAAC;CACtD;AAED,qBAAa,0CACX,YAAW,+BAA+B;IAE1C,QAAQ,CAAC,EAAE,iBAA0B;IAErC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAO9B,MAAM,CACX,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GACZ,cAAc,CAAC,UAAU,EAAE,eAAe,EAAE,IAAI,CAAC;CAwBrD;AAED,qBAAa,mCACX,YAAW,+BAA+B;IAE1C,QAAQ,CAAC,EAAE,SAAmB;IAE9B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAU9B,MAAM,CACX,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GACZ,cAAc,CAAC,UAAU,EAAE,eAAe,EAAE,IAAI,CAAC;CAmBrD;AAED,wBAAgB,6CAA6C,IAAI,SAAS,+BAA+B,EAAE,CAK1G"}

package/dist/agents/openai-compatible/response.js

@@ -0,0 +1,203 @@
+import { AGENT_ERROR_CODE, AgentError } from "../../core/error.js";
+import { redactSecrets } from "../../core/redact.js";
+import { AGENT_EVENT_TYPE } from "../../core/run.js";
+const CONTENT_TYPE_HEADER = "content-type";
+const APPLICATION_JSON = "application/json";
+const JSON_CONTENT_TYPE_SUFFIX = "+json";
+const TEXT_EVENT_STREAM = "text/event-stream";
+const STREAM_DONE = "[DONE]";
+const STDERR_TAIL_CHARS = 2_000;
+const DECODER_ID = {
+    eventStream: "event-stream",
+    json: "json",
+};
+const SSE_DATA_PREFIX = "data:";
+const OPENAI_RESPONSE_FIELD = {
+    choices: "choices",
+    completionTokens: "completion_tokens",
+    content: "content",
+    delta: "delta",
+    message: "message",
+    promptTokens: "prompt_tokens",
+    text: "text",
+    usage: "usage",
+};
+export class EventStreamOpenAiCompatibleResponseDecoder {
+    id = DECODER_ID.eventStream;
+    supports(response) {
+        return (response.headers.get(CONTENT_TYPE_HEADER)?.includes(TEXT_EVENT_STREAM) ===
+            true);
+    }
+    async *decode(response, model) {
+        const reader = response.body?.getReader();
+        if (reader === undefined) {
+            return emptyOutcome(model);
+        }
+        const decoder = new TextDecoder();
+        const state = {
+            buffer: "",
+            text: "",
+            usage: null,
+        };
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            state.buffer += decoder.decode(value, { stream: true });
+            yield* drainEventStreamLines(state);
+        }
+        state.buffer += decoder.decode();
+        yield* drainFinalEventStreamLine(state);
+        return { ...emptyOutcome(model), text: state.text, usage: state.usage };
+    }
+}
+export class JsonOpenAiCompatibleResponseDecoder {
+    id = DECODER_ID.json;
+    supports(response) {
+        const contentType = response.headers
+            .get(CONTENT_TYPE_HEADER)
+            ?.toLowerCase();
+        return (contentType?.includes(APPLICATION_JSON) === true ||
+            contentType?.includes(JSON_CONTENT_TYPE_SUFFIX) === true);
+    }
+    async *decode(response, model) {
+        const body = await response.text();
+        const parsed = parseJsonResponse(body);
+        const text = extractCompletionText(parsed);
+        if (text === null) {
+            throw invalidJsonResponseError("OpenAI-compatible endpoint returned JSON without completion text", body);
+        }
+        if (text !== "") {
+            yield { type: AGENT_EVENT_TYPE.message, text };
+        }
+        return {
+            ...emptyOutcome(model),
+            text,
+            usage: extractUsage(parsed),
+        };
+    }
+}
+export function createDefaultOpenAiCompatibleResponseDecoders() {
+    return [
+        new EventStreamOpenAiCompatibleResponseDecoder(),
+        new JsonOpenAiCompatibleResponseDecoder(),
+    ];
+}
+function* drainEventStreamLines(state) {
+    const lines = state.buffer.split(/\r?\n/u);
+    state.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+        const event = handleEventStreamLine(state, line);
+        if (event !== null) {
+            yield event;
+        }
+    }
+}
+function* drainFinalEventStreamLine(state) {
+    if (state.buffer.trim() === "") {
+        return;
+    }
+    const event = handleEventStreamLine(state, state.buffer);
+    if (event !== null) {
+        yield event;
+    }
+}
+function handleEventStreamLine(state, line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith(SSE_DATA_PREFIX)) {
+        return null;
+    }
+    const data = trimmed.slice(SSE_DATA_PREFIX.length).trim();
+    if (data === "" || data === STREAM_DONE) {
+        return null;
+    }
+    const parsed = safeJson(data);
+    const chunk = extractCompletionText(parsed);
+    state.usage = extractUsage(parsed) ?? state.usage;
+    if (chunk === null || chunk === "") {
+        return null;
+    }
+    state.text += chunk;
+    return { type: AGENT_EVENT_TYPE.message, text: chunk };
+}
+function emptyOutcome(model) {
+    return {
+        text: "",
+        model,
+        exit: null,
+        raw: null,
+        usage: null,
+    };
+}
+function extractCompletionText(value) {
+    const firstChoice = readArray(readRecord(value), OPENAI_RESPONSE_FIELD.choices)[0];
+    const choice = readRecord(firstChoice);
+    const deltaText = readString(readRecord(choice?.[OPENAI_RESPONSE_FIELD.delta]), OPENAI_RESPONSE_FIELD.content);
+    if (deltaText !== null) {
+        return deltaText;
+    }
+    const messageText = readString(readRecord(choice?.[OPENAI_RESPONSE_FIELD.message]), OPENAI_RESPONSE_FIELD.content);
+    if (messageText !== null) {
+        return messageText;
+    }
+    return readString(choice, OPENAI_RESPONSE_FIELD.text);
+}
+function extractUsage(value) {
+    const usage = readRecord(readRecord(value)?.[OPENAI_RESPONSE_FIELD.usage]);
+    if (usage === null) {
+        return null;
+    }
+    return {
+        inputTokens: readNumber(usage, OPENAI_RESPONSE_FIELD.promptTokens),
+        outputTokens: readNumber(usage, OPENAI_RESPONSE_FIELD.completionTokens),
+        costUsd: null,
+    };
+}
+function readRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readArray(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value : [];
+}
+function readString(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" ? value : null;
+}
+function readNumber(record, key) {
+    const value = record[key];
+    return typeof value === "number" ? value : null;
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function parseJsonResponse(body) {
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        throw invalidJsonResponseError("OpenAI-compatible endpoint returned malformed JSON", body);
+    }
+}
+function invalidJsonResponseError(message, body) {
+    const redactedBody = redactSecrets(body);
+    return new AgentError({
+        code: AGENT_ERROR_CODE.failed,
+        message,
+        data: {
+            exitCode: null,
+            stdoutTail: null,
+            stderrTail: redactedBody.length === 0
+                ? null
+                : redactedBody.slice(-STDERR_TAIL_CHARS),
+        },
+    });
+}

package/dist/agents/openai-compatible/types.d.ts

@@ -0,0 +1,34 @@
+import type { JsonValue } from "@alpacakit/core";
+import type { EnvTemplate } from "../../kernel/env-template.js";
+export type { JsonValue } from "@alpacakit/core";
+export type OpenAiCompatibleConfig<Id extends string = string> = {
+    readonly id: Id;
+    readonly baseUrl: EnvTemplate;
+    readonly model: EnvTemplate;
+    readonly apiKey: EnvTemplate | null;
+    readonly headers: Readonly<Record<string, EnvTemplate>>;
+    readonly requestParams: Readonly<Record<string, JsonValue>>;
+};
+/**
+ * Inbound config for `openaiCompatible` (rule 1): the fields that default
+ * cleanly to "absent" are optional — `apiKey` to `null`, `headers` and
+ * `requestParams` to `{}`. The factory normalizes this into the full
+ * `OpenAiCompatibleConfig` exactly once.
+ */
+export type OpenAiCompatibleConfigInput<Id extends string = string> = {
+    readonly id: Id;
+    readonly baseUrl: EnvTemplate;
+    readonly model: EnvTemplate;
+    readonly apiKey?: EnvTemplate | null;
+    readonly headers?: Readonly<Record<string, EnvTemplate>>;
+    readonly requestParams?: Readonly<Record<string, JsonValue>>;
+};
+export type ResolvedOpenAiCompatibleConfig = {
+    readonly id: string;
+    readonly baseUrl: string;
+    readonly model: string;
+    readonly apiKey: string | null;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly requestParams: Readonly<Record<string, JsonValue>>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/agents/openai-compatible/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/agents/openai-compatible/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,MAAM,MAAM,sBAAsB,CAAC,EAAE,SAAS,MAAM,GAAG,MAAM,IAAI;IAC/D,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC;IAChB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;CAC7D,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,CAAC,EAAE,SAAS,MAAM,GAAG,MAAM,IAAI;IACpE,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC;IAChB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IACzD,QAAQ,CAAC,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;CAC9D,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,aAAa,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;CAC7D,CAAC"}

package/dist/agents/openai-compatible/types.js

@@ -0,0 +1 @@
+export {};

package/dist/agents/openai-compatible.d.ts

@@ -0,0 +1,12 @@
+import { type AgentDefinition } from "../kernel/definition.js";
+import { type OpenAiCompatibleConfigResolver } from "./openai-compatible/config.js";
+import type { OpenAiCompatibleEngine } from "./openai-compatible/engine.js";
+import type { OpenAiCompatibleConfigInput } from "./openai-compatible/types.js";
+export type { OpenAiCompatibleEngine } from "./openai-compatible/engine.js";
+export type { JsonValue, OpenAiCompatibleConfig, OpenAiCompatibleConfigInput, } from "./openai-compatible/types.js";
+type OpenAiCompatibleDependencies = {
+    readonly configResolver?: OpenAiCompatibleConfigResolver;
+    readonly engine?: OpenAiCompatibleEngine;
+};
+export declare function openaiCompatible<const Id extends string>(config: OpenAiCompatibleConfigInput<Id>, dependencies?: OpenAiCompatibleDependencies): AgentDefinition<Id>;
+//# sourceMappingURL=openai-compatible.d.ts.map

package/dist/agents/openai-compatible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-compatible.d.ts","sourceRoot":"","sources":["../../src/agents/openai-compatible.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAEL,KAAK,8BAA8B,EACpC,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E,OAAO,KAAK,EAEV,2BAA2B,EAC5B,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAC5E,YAAY,EACV,SAAS,EACT,sBAAsB,EACtB,2BAA2B,GAC5B,MAAM,8BAA8B,CAAC;AAEtC,KAAK,4BAA4B,GAAG;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,8BAA8B,CAAC;IACzD,QAAQ,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC;CAC1C,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EACtD,MAAM,EAAE,2BAA2B,CAAC,EAAE,CAAC,EACvC,YAAY,GAAE,4BAAiC,GAC9C,eAAe,CAAC,EAAE,CAAC,CA8BrB"}

package/dist/agents/openai-compatible.js

@@ -0,0 +1,45 @@
+import { DOCTOR_CHECK_STATUS } from "../host/capabilities.js";
+import { defineAgent, } from "../kernel/definition.js";
+import { defaultOpenAiCompatibleConfigResolver, } from "./openai-compatible/config.js";
+import { defaultOpenAiCompatibleEngine } from "./openai-compatible/fetch-engine.js";
+export function openaiCompatible(config, dependencies = {}) {
+    const configResolver = dependencies.configResolver ?? defaultOpenAiCompatibleConfigResolver;
+    const engine = dependencies.engine ?? defaultOpenAiCompatibleEngine;
+    const normalized = configResolver.normalize(withConfigDefaults(config));
+    return defineAgent({
+        id: normalized.id,
+        run: (options, ctx) => runOpenAiCompatible({
+            config: normalized,
+            configResolver,
+            engine,
+            options,
+            ctx,
+        }),
+        doctor: {
+            probe: async (ctx) => {
+                const checks = [
+                    ...configResolver.doctorChecks(normalized, ctx.env),
+                    ...(await engine.doctorChecks()),
+                ];
+                return {
+                    available: checks.every((check) => check.status === DOCTOR_CHECK_STATUS.pass),
+                    checks,
+                };
+            },
+        },
+    });
+}
+function withConfigDefaults(config) {
+    return {
+        id: config.id,
+        baseUrl: config.baseUrl,
+        model: config.model,
+        apiKey: config.apiKey ?? null,
+        headers: config.headers ?? {},
+        requestParams: config.requestParams ?? {},
+    };
+}
+async function* runOpenAiCompatible(input) {
+    const resolved = input.configResolver.resolve(input.config, input.ctx.env);
+    return yield* input.engine.run(resolved, input.options, input.ctx);
+}