@alpacakit/agents 0.1.0-beta.19

package/dist/codex/protocol.js

@@ -0,0 +1,283 @@
+/**
+ * The app-server method registry: adding a method adds a row in
+ * `CodexAppServerMethods` plus its decoder row in
+ * `CODEX_APP_SERVER_RESULT_DECODERS`. Result rows are RESOLVED shapes
+ * (rule 2): meaningful absence is `null` / empty collection, never `?`.
+ * The decoders normalize the foreign JSON-RPC payload at the boundary
+ * (rule 1) — strict on the fields consumers depend on, normalizing on
+ * fields the server may omit — so a malformed server response becomes a
+ * typed failure in the client instead of a TypeError in a caller.
+ */
+import { readArray, readBoolean, readString, readUnknownRecord, } from "../core/json.js";
+export const CODEX_APP_SERVER_METHOD = {
+    initialize: "initialize",
+    initialized: "initialized",
+    pluginList: "plugin/list",
+    pluginInstall: "plugin/install",
+    skillsList: "skills/list",
+    mcpServerStatusList: "mcpServerStatus/list",
+};
+export const CODEX_MCP_STATUS_DETAIL = {
+    toolsAndAuthOnly: "toolsAndAuthOnly",
+};
+const RESULT_FIELD = {
+    alreadyInstalled: "alreadyInstalled",
+    appsNeedingAuth: "appsNeedingAuth",
+    authPolicy: "authPolicy",
+    authStatus: "authStatus",
+    capabilities: "capabilities",
+    cwd: "cwd",
+    data: "data",
+    description: "description",
+    displayName: "displayName",
+    enabled: "enabled",
+    errors: "errors",
+    id: "id",
+    installPolicy: "installPolicy",
+    installed: "installed",
+    interface: "interface",
+    location: "location",
+    longDescription: "longDescription",
+    marketplaceLoadErrors: "marketplaceLoadErrors",
+    marketplacePath: "marketplacePath",
+    marketplaces: "marketplaces",
+    message: "message",
+    name: "name",
+    nextCursor: "nextCursor",
+    path: "path",
+    plugins: "plugins",
+    scope: "scope",
+    shortDescription: "shortDescription",
+    skills: "skills",
+    status: "status",
+    tools: "tools",
+};
+export const CODEX_APP_SERVER_RESULT_DECODERS = {
+    [CODEX_APP_SERVER_METHOD.pluginList]: decodePluginListResult,
+    [CODEX_APP_SERVER_METHOD.pluginInstall]: decodePluginInstallResult,
+    [CODEX_APP_SERVER_METHOD.skillsList]: decodeSkillListResult,
+    [CODEX_APP_SERVER_METHOD.mcpServerStatusList]: decodeMcpServerStatusPage,
+};
+function decodeItems(values, decodeItem) {
+    const items = [];
+    for (const value of values) {
+        const item = decodeItem(value);
+        if (item === null) {
+            return null;
+        }
+        items.push(item);
+    }
+    return items;
+}
+function decodePluginListResult(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const marketplaceValues = readArray(record, RESULT_FIELD.marketplaces);
+    if (marketplaceValues === null) {
+        return null;
+    }
+    const marketplaces = decodeItems(marketplaceValues, decodePluginMarketplace);
+    const loadErrors = decodeItems(readArray(record, RESULT_FIELD.marketplaceLoadErrors) ?? [], decodeMarketplaceLoadError);
+    if (marketplaces === null || loadErrors === null) {
+        return null;
+    }
+    return { marketplaces, marketplaceLoadErrors: loadErrors };
+}
+function decodePluginMarketplace(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const name = readString(record, RESULT_FIELD.name);
+    const pluginValues = readArray(record, RESULT_FIELD.plugins);
+    if (name === null || pluginValues === null) {
+        return null;
+    }
+    const plugins = decodeItems(pluginValues, decodePluginSummary);
+    if (plugins === null) {
+        return null;
+    }
+    return { name, path: readString(record, RESULT_FIELD.path), plugins };
+}
+function decodePluginSummary(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const id = readString(record, RESULT_FIELD.id);
+    const name = readString(record, RESULT_FIELD.name);
+    const installed = readBoolean(record, RESULT_FIELD.installed);
+    const enabled = readBoolean(record, RESULT_FIELD.enabled);
+    const installPolicy = readString(record, RESULT_FIELD.installPolicy);
+    if (id === null ||
+        name === null ||
+        installed === null ||
+        enabled === null ||
+        installPolicy === null) {
+        return null;
+    }
+    return {
+        id,
+        name,
+        installed,
+        enabled,
+        installPolicy,
+        interface: decodePluginInterface(record[RESULT_FIELD.interface]),
+    };
+}
+/** Absent / malformed interface metadata is `null`, never a decode failure. */
+function decodePluginInterface(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const capabilities = (readArray(record, RESULT_FIELD.capabilities) ?? []).filter((capability) => typeof capability === "string");
+    return {
+        displayName: readString(record, RESULT_FIELD.displayName),
+        shortDescription: readString(record, RESULT_FIELD.shortDescription),
+        longDescription: readString(record, RESULT_FIELD.longDescription),
+        capabilities,
+    };
+}
+function decodeMarketplaceLoadError(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const marketplacePath = readString(record, RESULT_FIELD.marketplacePath);
+    const message = readString(record, RESULT_FIELD.message);
+    if (marketplacePath === null || message === null) {
+        return null;
+    }
+    return { marketplacePath, message };
+}
+function decodePluginInstallResult(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const status = readString(record, RESULT_FIELD.status);
+    const alreadyInstalled = readBoolean(record, RESULT_FIELD.alreadyInstalled);
+    const appsNeedingAuth = readArray(record, RESULT_FIELD.appsNeedingAuth);
+    const authPolicy = readString(record, RESULT_FIELD.authPolicy);
+    const hasAuthResult = appsNeedingAuth !== null && authPolicy !== null;
+    const hasExplicitInstallResult = status !== null || alreadyInstalled !== null;
+    if (!hasAuthResult && !hasExplicitInstallResult) {
+        return null;
+    }
+    return {
+        status,
+        alreadyInstalled,
+        appsNeedingAuth: appsNeedingAuth ?? [],
+        authPolicy,
+        location: readString(record, RESULT_FIELD.location),
+    };
+}
+function decodeSkillListResult(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const entryValues = readArray(record, RESULT_FIELD.data);
+    if (entryValues === null) {
+        return null;
+    }
+    const data = decodeItems(entryValues, decodeSkillListEntry);
+    return data === null ? null : { data };
+}
+function decodeSkillListEntry(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const cwd = readString(record, RESULT_FIELD.cwd);
+    const skillValues = readArray(record, RESULT_FIELD.skills);
+    if (cwd === null || skillValues === null) {
+        return null;
+    }
+    const skills = decodeItems(skillValues, decodeSkillSummary);
+    const errors = decodeItems(readArray(record, RESULT_FIELD.errors) ?? [], decodeSkillListEntryError);
+    if (skills === null || errors === null) {
+        return null;
+    }
+    return { cwd, skills, errors };
+}
+function decodeSkillSummary(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const name = readString(record, RESULT_FIELD.name);
+    const description = readString(record, RESULT_FIELD.description);
+    const enabled = readBoolean(record, RESULT_FIELD.enabled);
+    const path = readString(record, RESULT_FIELD.path);
+    const scope = readString(record, RESULT_FIELD.scope);
+    if (name === null ||
+        description === null ||
+        enabled === null ||
+        path === null ||
+        scope === null) {
+        return null;
+    }
+    return { name, description, enabled, path, scope };
+}
+function decodeSkillListEntryError(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const path = readString(record, RESULT_FIELD.path);
+    const message = readString(record, RESULT_FIELD.message);
+    if (path === null || message === null) {
+        return null;
+    }
+    return { path, message };
+}
+function decodeMcpServerStatusPage(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const statusValues = readArray(record, RESULT_FIELD.data);
+    if (statusValues === null) {
+        return null;
+    }
+    const data = decodeItems(statusValues, decodeMcpServerStatus);
+    if (data === null) {
+        return null;
+    }
+    return { data, nextCursor: readString(record, RESULT_FIELD.nextCursor) };
+}
+function decodeMcpServerStatus(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const name = readString(record, RESULT_FIELD.name);
+    const authStatus = readString(record, RESULT_FIELD.authStatus);
+    if (name === null || authStatus === null) {
+        return null;
+    }
+    return {
+        name,
+        authStatus,
+        tools: decodeMcpTools(record[RESULT_FIELD.tools]),
+    };
+}
+/** A server that omits tool enumeration decodes to `null`, not `{}`. */
+function decodeMcpTools(value) {
+    const record = readUnknownRecord(value);
+    if (record === null) {
+        return null;
+    }
+    const tools = {};
+    for (const [key, tool] of Object.entries(record)) {
+        const toolRecord = readUnknownRecord(tool);
+        tools[key] = {
+            name: toolRecord === null ? null : readString(toolRecord, RESULT_FIELD.name),
+        };
+    }
+    return tools;
+}

package/dist/config/agent-config-validation.d.ts

@@ -0,0 +1,22 @@
+import { type JsonObject } from "@alpacakit/core";
+import type { AgentConfigKind } from "./ids.js";
+import type { AgentConfigType, AgentConfig, AgentConfigTypeRegistry } from "./model.js";
+export declare const AGENT_CONFIG_VALIDATION_RESULT: {
+    readonly valid: "valid";
+    readonly unknownKind: "unknown_kind";
+    readonly invalidPayload: "invalid_payload";
+};
+export type AgentConfigValidationResult = {
+    readonly kind: typeof AGENT_CONFIG_VALIDATION_RESULT.valid;
+    readonly definition: AgentConfigType<AgentConfigKind, JsonObject, string>;
+    readonly record: AgentConfig<AgentConfigKind, JsonObject>;
+} | {
+    readonly kind: typeof AGENT_CONFIG_VALIDATION_RESULT.unknownKind;
+    readonly agentConfigKind: AgentConfigKind;
+} | {
+    readonly kind: typeof AGENT_CONFIG_VALIDATION_RESULT.invalidPayload;
+    readonly agentConfigKind: AgentConfigKind;
+    readonly issues: readonly string[];
+};
+export declare function validateAgentConfig(record: AgentConfig<AgentConfigKind, JsonObject>, agentConfigTypes: AgentConfigTypeRegistry): AgentConfigValidationResult;
+//# sourceMappingURL=agent-config-validation.d.ts.map

package/dist/config/agent-config-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-config-validation.d.ts","sourceRoot":"","sources":["../../src/config/agent-config-validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,8BAA8B;;;;CAIjC,CAAC;AAEX,MAAM,MAAM,2BAA2B,GACnC;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,8BAA8B,CAAC,KAAK,CAAC;IAC3D,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC,eAAe,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAC1E,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;CAC3D,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,8BAA8B,CAAC,WAAW,CAAC;IACjE,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;CAC3C,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,8BAA8B,CAAC,cAAc,CAAC;IACpE,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CAAC;AAEN,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,WAAW,CAAC,eAAe,EAAE,UAAU,CAAC,EAChD,gBAAgB,EAAE,uBAAuB,GACxC,2BAA2B,CA0B7B"}

package/dist/config/agent-config-validation.js

@@ -0,0 +1,31 @@
+import { CODEC_DECODE_RESULT_KIND } from "@alpacakit/core";
+export const AGENT_CONFIG_VALIDATION_RESULT = {
+    valid: "valid",
+    unknownKind: "unknown_kind",
+    invalidPayload: "invalid_payload",
+};
+export function validateAgentConfig(record, agentConfigTypes) {
+    const definition = agentConfigTypes.get(record.kind);
+    if (definition === null) {
+        return {
+            kind: AGENT_CONFIG_VALIDATION_RESULT.unknownKind,
+            agentConfigKind: record.kind,
+        };
+    }
+    const decoded = definition.payloadCodec.decode(record.payload);
+    if (decoded.kind === CODEC_DECODE_RESULT_KIND.invalid) {
+        return {
+            kind: AGENT_CONFIG_VALIDATION_RESULT.invalidPayload,
+            agentConfigKind: definition.kind,
+            issues: decoded.issues,
+        };
+    }
+    return {
+        kind: AGENT_CONFIG_VALIDATION_RESULT.valid,
+        definition,
+        record: {
+            ...record,
+            payload: decoded.value,
+        },
+    };
+}

package/dist/config/agent-configs.d.ts

@@ -0,0 +1,37 @@
+import { type JsonObject } from "@alpacakit/core";
+import { type AgentConfigKind } from "./ids.js";
+import type { AgentConfig, AgentConfigType, AgentConfigTypeRegistry } from "./model.js";
+import { AGENT_CONFIG_KIND } from "./values.js";
+type BuiltinAgentConfigPayload = {
+    readonly model: string | null;
+    readonly effort: string | null;
+};
+type OpenAiCompatibleAgentConfigPayload = {
+    readonly baseUrl: string;
+    readonly model: string;
+    readonly apiKey: string | null;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly requestParams: JsonObject;
+};
+export type BuiltinAgentConfigOptions = {
+    readonly id: string;
+    readonly enabled?: boolean;
+    readonly model?: string;
+    readonly effort?: string;
+};
+export type OpenAiCompatibleAgentConfigOptions = {
+    readonly id: string;
+    readonly enabled?: boolean;
+    readonly baseUrl: string;
+    readonly model: string;
+    readonly apiKey?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly requestParams?: JsonObject;
+};
+export declare function codexAgentConfig(options: BuiltinAgentConfigOptions): AgentConfig<typeof AGENT_CONFIG_KIND.codex, BuiltinAgentConfigPayload>;
+export declare function claudeAgentConfig(options: BuiltinAgentConfigOptions): AgentConfig<typeof AGENT_CONFIG_KIND.claude, BuiltinAgentConfigPayload>;
+export declare function openAiCompatibleAgentConfig(options: OpenAiCompatibleAgentConfigOptions): AgentConfig<typeof AGENT_CONFIG_KIND.openaiCompatible, OpenAiCompatibleAgentConfigPayload>;
+export declare function createDefaultAgentConfigTypeRegistry(): AgentConfigTypeRegistry;
+export declare function defineAgentConfigType<Kind extends AgentConfigKind, Payload extends JsonObject, AgentId extends string>(definition: AgentConfigType<Kind, Payload, AgentId>): AgentConfigType<Kind, Payload, AgentId>;
+export {};
+//# sourceMappingURL=agent-configs.d.ts.map

package/dist/config/agent-configs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-configs.d.ts","sourceRoot":"","sources":["../../src/config/agent-configs.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EAEhB,MAAM,iBAAiB,CAAC;AAQzB,OAAO,EAAE,KAAK,eAAe,EAAiB,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EAGf,uBAAuB,EAGxB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,iBAAiB,EAGlB,MAAM,aAAa,CAAC;AAQrB,KAAK,yBAAyB,GAAG;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC,CAAC;AAOF,KAAK,kCAAkC,GAAG;IACxC,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,UAAU,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,QAAQ,CAAC,aAAa,CAAC,EAAE,UAAU,CAAC;CACrC,CAAC;AAiCF,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,yBAAyB,GACjC,WAAW,CAAC,OAAO,iBAAiB,CAAC,KAAK,EAAE,yBAAyB,CAAC,CAExE;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,yBAAyB,GACjC,WAAW,CAAC,OAAO,iBAAiB,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAEzE;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,kCAAkC,GAC1C,WAAW,CACZ,OAAO,iBAAiB,CAAC,gBAAgB,EACzC,kCAAkC,CACnC,CAaA;AA2CD,wBAAgB,oCAAoC,IAAI,uBAAuB,CAoB9E;AAED,wBAAgB,qBAAqB,CACnC,IAAI,SAAS,eAAe,EAC5B,OAAO,SAAS,UAAU,EAC1B,OAAO,SAAS,MAAM,EAEtB,UAAU,EAAE,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,GAClD,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAEzC"}

package/dist/config/agent-configs.js

@@ -0,0 +1,214 @@
+import { createKeyedRegistry, createSchemaRuntimeCodec, jsonValueSchema, } from "@alpacakit/core";
+import { z } from "zod";
+import { claude } from "../agents/claude.js";
+import { codex } from "../agents/codex.js";
+import { openaiCompatible } from "../agents/openai-compatible.js";
+import { agentConfigId } from "./ids.js";
+import { formatFieldPath, ZOD_ISSUE_CODE } from "./support.js";
+import { AGENT_CONFIG_KIND, BUILTIN_AGENT_ID, CANDIDATE_SOURCE_KIND, } from "./values.js";
+const ENV_TEMPLATE_EXPRESSION_START = "${";
+const OPENAI_COMPATIBLE_PAYLOAD_FIELD = {
+    apiKey: "apiKey",
+    headers: "headers",
+};
+const OPENAI_COMPATIBLE_SECRET_FIELD = {
+    apiKey: {
+        label: OPENAI_COMPATIBLE_PAYLOAD_FIELD.apiKey,
+        path: [OPENAI_COMPATIBLE_PAYLOAD_FIELD.apiKey],
+    },
+};
+const OPENAI_COMPATIBLE_SECRET_HEADER = {
+    authorization: "authorization",
+    proxyAuthorization: "proxy-authorization",
+    apiKey: "api-key",
+    xApiKey: "x-api-key",
+};
+const AGENT_CONFIG_PAYLOAD_ERROR = {
+    directSecret: (label) => `${label} must use an environment template instead of a direct secret.`,
+};
+const secretHeaderNames = new Set(Object.values(OPENAI_COMPATIBLE_SECRET_HEADER));
+export function codexAgentConfig(options) {
+    return builtinAgentConfigRecord(AGENT_CONFIG_KIND.codex, options);
+}
+export function claudeAgentConfig(options) {
+    return builtinAgentConfigRecord(AGENT_CONFIG_KIND.claude, options);
+}
+export function openAiCompatibleAgentConfig(options) {
+    return {
+        id: agentConfigId(options.id),
+        kind: AGENT_CONFIG_KIND.openaiCompatible,
+        enabled: options.enabled ?? true,
+        payload: {
+            baseUrl: options.baseUrl,
+            model: options.model,
+            apiKey: options.apiKey ?? null,
+            headers: options.headers ?? {},
+            requestParams: options.requestParams ?? {},
+        },
+    };
+}
+const builtinAgentConfigPayloadCodec = createSchemaRuntimeCodec(z
+    .object({
+    model: z.string().min(1).nullable(),
+    effort: z.string().min(1).nullable(),
+})
+    .strict()
+    .readonly());
+const openAiCompatibleAgentConfigPayloadCodec = createSchemaRuntimeCodec(z
+    .object({
+    baseUrl: z.string().min(1),
+    model: z.string().min(1),
+    apiKey: z.string().min(1).nullable(),
+    headers: z.record(z.string(), z.string().min(1)).readonly(),
+    requestParams: z.record(z.string(), jsonValueSchema).readonly(),
+})
+    .strict()
+    .readonly()
+    .superRefine((payload, context) => {
+    rejectDirectSecretIfPresent(payload.apiKey, OPENAI_COMPATIBLE_SECRET_FIELD.apiKey, context);
+    for (const [name, value] of Object.entries(payload.headers)) {
+        if (secretHeaderNames.has(name.toLowerCase())) {
+            rejectDirectSecretIfPresent(value, headerSecretField(name), context);
+        }
+    }
+}));
+export function createDefaultAgentConfigTypeRegistry() {
+    return createKeyedRegistry([
+        createBuiltinAgentConfig({
+            kind: AGENT_CONFIG_KIND.codex,
+            agentId: BUILTIN_AGENT_ID.codex,
+            defineAgent: codex,
+        }),
+        createBuiltinAgentConfig({
+            kind: AGENT_CONFIG_KIND.claude,
+            agentId: BUILTIN_AGENT_ID.claude,
+            defineAgent: claude,
+        }),
+        createOpenAiCompatibleAgentConfig(),
+    ], (definition) => definition.kind);
+}
+export function defineAgentConfigType(definition) {
+    return definition;
+}
+function createBuiltinAgentConfig(input) {
+    return defineAgentConfigType({
+        kind: input.kind,
+        payloadCodec: builtinAgentConfigPayloadCodec,
+        project: (projectionInput) => projectBuiltinAgentConfig({
+            ...projectionInput,
+            agentId: input.agentId,
+            defineAgent: input.defineAgent,
+        }),
+    });
+}
+function projectBuiltinAgentConfig(input) {
+    const candidateDefaults = normalizeBuiltinCandidateDefaults(input.record.payload);
+    const matchingProfiles = input.profiles.filter((profile) => profile.agentId === input.agentId);
+    const candidates = matchingProfiles.map((profile) => profileCandidate(input.record, candidateDefaults, profile));
+    if (input.ambientBuiltinAuth) {
+        candidates.push(ambientCandidate(input.record, candidateDefaults, input.agentId));
+    }
+    return {
+        agents: [input.defineAgent()],
+        candidates,
+    };
+}
+function profileCandidate(record, candidateDefaults, profile) {
+    return {
+        candidate: withBuiltinDefaults({
+            agentId: profile.agentId,
+            profile,
+        }, candidateDefaults),
+        source: {
+            agentConfigId: record.id,
+            agentConfigKind: record.kind,
+            profileId: profile.id,
+            kind: CANDIDATE_SOURCE_KIND.profile,
+        },
+    };
+}
+function ambientCandidate(record, candidateDefaults, agentId) {
+    return {
+        candidate: withBuiltinDefaults({ agentId }, candidateDefaults),
+        source: {
+            agentConfigId: record.id,
+            agentConfigKind: record.kind,
+            profileId: null,
+            kind: CANDIDATE_SOURCE_KIND.ambient,
+        },
+    };
+}
+function withBuiltinDefaults(candidate, candidateDefaults) {
+    return {
+        ...candidate,
+        ...candidateDefaults,
+    };
+}
+function normalizeBuiltinCandidateDefaults(payload) {
+    return {
+        ...(payload.model === null ? {} : { model: payload.model }),
+        ...(payload.effort === null ? {} : { effort: payload.effort }),
+    };
+}
+function createOpenAiCompatibleAgentConfig() {
+    return defineAgentConfigType({
+        kind: AGENT_CONFIG_KIND.openaiCompatible,
+        payloadCodec: openAiCompatibleAgentConfigPayloadCodec,
+        project: (input) => {
+            const agentId = String(input.record.id);
+            const config = {
+                id: agentId,
+                baseUrl: input.record.payload.baseUrl,
+                model: input.record.payload.model,
+                apiKey: input.record.payload.apiKey,
+                headers: input.record.payload.headers,
+                requestParams: input.record.payload.requestParams,
+            };
+            return {
+                agents: [openaiCompatible(config)],
+                candidates: [
+                    {
+                        candidate: { agentId, model: input.record.payload.model },
+                        source: {
+                            agentConfigId: input.record.id,
+                            agentConfigKind: input.record.kind,
+                            profileId: null,
+                            kind: CANDIDATE_SOURCE_KIND.configured,
+                        },
+                    },
+                ],
+            };
+        },
+    });
+}
+function rejectDirectSecretIfPresent(value, field, context) {
+    if (value === null) {
+        return;
+    }
+    if (value.includes(ENV_TEMPLATE_EXPRESSION_START)) {
+        return;
+    }
+    context.addIssue({
+        code: ZOD_ISSUE_CODE.custom,
+        path: [...field.path],
+        message: AGENT_CONFIG_PAYLOAD_ERROR.directSecret(field.label),
+    });
+}
+function headerSecretField(name) {
+    const path = [OPENAI_COMPATIBLE_PAYLOAD_FIELD.headers, name];
+    return {
+        label: formatFieldPath(path),
+        path,
+    };
+}
+function builtinAgentConfigRecord(kind, options) {
+    return {
+        id: agentConfigId(options.id),
+        kind,
+        enabled: options.enabled ?? true,
+        payload: {
+            model: options.model ?? null,
+            effort: options.effort ?? null,
+        },
+    };
+}

package/dist/config/compose.d.ts

@@ -0,0 +1,10 @@
+import type { AgentConfigTypeRegistry, AgentsRuntimeConfig, ConfigData, NamedSecretResolver } from "./model.js";
+type ComposeAgentsRuntimeConfigOptions = {
+    readonly data: ConfigData;
+    readonly fleetStateStore: AgentsRuntimeConfig["fleetStateStore"];
+    readonly agentConfigTypes: AgentConfigTypeRegistry;
+    readonly secretResolvers: readonly NamedSecretResolver[];
+};
+export declare function composeRuntimeConfig(input: ComposeAgentsRuntimeConfigOptions): AgentsRuntimeConfig;
+export {};
+//# sourceMappingURL=compose.d.ts.map

package/dist/config/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../../src/config/compose.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,uBAAuB,EACvB,mBAAmB,EACnB,UAAU,EAEV,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAwBpB,KAAK,iCAAiC,GAAG;IACvC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;IACjE,QAAQ,CAAC,gBAAgB,EAAE,uBAAuB,CAAC;IACnD,QAAQ,CAAC,eAAe,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC1D,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,iCAAiC,GACvC,mBAAmB,CA2CrB"}