@shipfox/api-agent-dto 2.0.0

package/dist/schemas/index.js

@@ -0,0 +1,10 @@
+export { agentModelOptionSchema, agentThinkingByHarness, agentThinkingSchema, claudeAgentThinkingSchema, DEFAULT_AGENT_THINKING, DEFAULT_HARNESS, DEFAULT_MODEL_PROVIDER, getModelProviderEntry, harnessSchema, listSupportedModelProviders, MODEL_PROVIDER_CATALOG_SEED, modelProviderCatalogEntrySchema, modelProviderCatalogResponseSchema, modelProviderCatalogSeedSchema, modelProviderCredentialFieldSchema, modelProviderSupportStatusSchema, piAgentThinkingSchema, thinkingLevelsForHarness } from './catalog.js';
+export { createCustomModelProviderBodySchema, customAgentModelSchema, customModelProviderConfigDtoSchema, customModelProviderHeaderDtoSchema, customModelProviderHeaderRequestSchema, customModelProviderRuntimeConfigSchema, DEFAULT_CUSTOM_MODEL_CONTEXT_WINDOW, DEFAULT_CUSTOM_MODEL_INPUT_IMAGE, DEFAULT_CUSTOM_MODEL_MAX_OUTPUT_TOKENS, DEFAULT_CUSTOM_MODEL_REASONING, discoverCustomModelProviderModelsBodySchema, discoverCustomModelProviderModelsBySlugBodySchema, discoverCustomModelProviderModelsResponseSchema, MAX_MODEL_COUNT, modelProviderApiSchema, updateCustomModelProviderBodySchema, updateCustomModelProviderHeaderRequestSchema } from './custom-model-provider.js';
+export { buildHarnessToolDeploymentConfig, CLAUDE_HARNESS, DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG, DEFAULT_PI_ENABLED_TOOL_PACKAGES, DEFAULT_PI_WEB_SEARCH_ENABLED, getHarnessDescriptor, getHarnessToolDescriptor, HARNESS_TOOL_PACKAGE_NAMES, harnessSupportsProvider, harnessSupportsTool, listEnabledHarnessTools, listHarnessDescriptors, listHarnessTools, PI_HARNESS, PI_HARNESS_TOOL_PACKAGE_NAMES, parsePiEnabledToolPackages } from './harness.js';
+export { AGENT_INTEGRATION_MCP_AUTH, AGENT_INTEGRATION_MCP_ENDPOINT, AGENT_INTEGRATION_MCP_SERVER_NAME, AGENT_INTEGRATION_MCP_TRANSPORT, agentIntegrationMcpServerSchema, materializedAgentIntegrationSchema, materializedAgentIntegrationToolSchema, materializedAgentStepConfigSchema } from './materialized-agent-step-config.js';
+export { getModelProviderCredentialKeys, listModelProviderConfigsResponseSchema, modelProviderConfigDtoSchema, modelProviderConfigResponseSchema, modelProviderCredentialKeysMatch, setDefaultModelProviderBodySchema, setDefaultModelProviderResponseSchema, updateModelProviderConfigBodySchema, updateModelProviderDefaultModelBodySchema } from './model-provider-config.js';
+export { isReservedModelProviderId, MODEL_PROVIDER_IDS, MODEL_PROVIDER_SLUG_PATTERN, modelProviderRefSchema, providerIdSchema, SUPPORTED_MODEL_PROVIDER_IDS, supportedModelProviderIdSchema, UNSUPPORTED_MODEL_PROVIDER_IDS } from './model-provider-id.js';
+export { agentRuntimeCredentialsResponseSchema } from './runtime-config.js';
+export { setDefaultHarnessBodySchema, setDefaultHarnessResponseSchema } from './workspace-defaults.js';
+
+//# sourceMappingURL=index.js.map

package/dist/schemas/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/index.ts"],"sourcesContent":["export {\n  type AgentModelOptionDto,\n  type AgentThinking,\n  agentModelOptionSchema,\n  agentThinkingByHarness,\n  agentThinkingSchema,\n  claudeAgentThinkingSchema,\n  DEFAULT_AGENT_THINKING,\n  DEFAULT_HARNESS,\n  DEFAULT_MODEL_PROVIDER,\n  getModelProviderEntry,\n  type Harness,\n  harnessSchema,\n  listSupportedModelProviders,\n  MODEL_PROVIDER_CATALOG_SEED,\n  type ModelProviderCatalogEntryDto,\n  type ModelProviderCatalogResponseDto,\n  type ModelProviderCatalogSeedDto,\n  type ModelProviderCredentialFieldDto,\n  type ModelProviderSupportStatus,\n  modelProviderCatalogEntrySchema,\n  modelProviderCatalogResponseSchema,\n  modelProviderCatalogSeedSchema,\n  modelProviderCredentialFieldSchema,\n  modelProviderSupportStatusSchema,\n  piAgentThinkingSchema,\n  thinkingLevelsForHarness,\n} from './catalog.js';\nexport {\n  type CreateCustomModelProviderBodyDto,\n  type CustomAgentModelDto,\n  type CustomModelProviderConfigDto,\n  type CustomModelProviderHeaderDto,\n  type CustomModelProviderHeaderRequestDto,\n  type CustomModelProviderRuntimeConfigDto,\n  createCustomModelProviderBodySchema,\n  customAgentModelSchema,\n  customModelProviderConfigDtoSchema,\n  customModelProviderHeaderDtoSchema,\n  customModelProviderHeaderRequestSchema,\n  customModelProviderRuntimeConfigSchema,\n  DEFAULT_CUSTOM_MODEL_CONTEXT_WINDOW,\n  DEFAULT_CUSTOM_MODEL_INPUT_IMAGE,\n  DEFAULT_CUSTOM_MODEL_MAX_OUTPUT_TOKENS,\n  DEFAULT_CUSTOM_MODEL_REASONING,\n  type DiscoverCustomModelProviderModelsBodyDto,\n  type DiscoverCustomModelProviderModelsBySlugBodyDto,\n  type DiscoverCustomModelProviderModelsResponseDto,\n  discoverCustomModelProviderModelsBodySchema,\n  discoverCustomModelProviderModelsBySlugBodySchema,\n  discoverCustomModelProviderModelsResponseSchema,\n  MAX_MODEL_COUNT,\n  type ModelProviderApi,\n  modelProviderApiSchema,\n  type UpdateCustomModelProviderBodyDto,\n  type UpdateCustomModelProviderHeaderRequestDto,\n  updateCustomModelProviderBodySchema,\n  updateCustomModelProviderHeaderRequestSchema,\n} from './custom-model-provider.js';\nexport {\n  buildHarnessToolDeploymentConfig,\n  CLAUDE_HARNESS,\n  DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG,\n  DEFAULT_PI_ENABLED_TOOL_PACKAGES,\n  DEFAULT_PI_WEB_SEARCH_ENABLED,\n  getHarnessDescriptor,\n  getHarnessToolDescriptor,\n  HARNESS_TOOL_PACKAGE_NAMES,\n  type HarnessDescriptor,\n  type HarnessToolDeploymentConfig,\n  type HarnessToolDescriptor,\n  type HarnessToolPackageName,\n  harnessSupportsProvider,\n  harnessSupportsTool,\n  listEnabledHarnessTools,\n  listHarnessDescriptors,\n  listHarnessTools,\n  PI_HARNESS,\n  PI_HARNESS_TOOL_PACKAGE_NAMES,\n  parsePiEnabledToolPackages,\n} from './harness.js';\nexport {\n  AGENT_INTEGRATION_MCP_AUTH,\n  AGENT_INTEGRATION_MCP_ENDPOINT,\n  AGENT_INTEGRATION_MCP_SERVER_NAME,\n  AGENT_INTEGRATION_MCP_TRANSPORT,\n  type AgentIntegrationMcpServerConfigDto,\n  agentIntegrationMcpServerSchema,\n  type MaterializedAgentIntegrationConfigDto,\n  type MaterializedAgentIntegrationToolConfigDto,\n  type MaterializedAgentStepConfigDto,\n  materializedAgentIntegrationSchema,\n  materializedAgentIntegrationToolSchema,\n  materializedAgentStepConfigSchema,\n} from './materialized-agent-step-config.js';\nexport {\n  getModelProviderCredentialKeys,\n  type ListModelProviderConfigsResponseDto,\n  listModelProviderConfigsResponseSchema,\n  type ModelProviderConfigDto,\n  type ModelProviderConfigResponseDto,\n  modelProviderConfigDtoSchema,\n  modelProviderConfigResponseSchema,\n  modelProviderCredentialKeysMatch,\n  type SetDefaultModelProviderBodyDto,\n  type SetDefaultModelProviderResponseDto,\n  setDefaultModelProviderBodySchema,\n  setDefaultModelProviderResponseSchema,\n  type UpdateModelProviderConfigBodyDto,\n  type UpdateModelProviderDefaultModelBodyDto,\n  updateModelProviderConfigBodySchema,\n  updateModelProviderDefaultModelBodySchema,\n} from './model-provider-config.js';\nexport {\n  isReservedModelProviderId,\n  MODEL_PROVIDER_IDS,\n  MODEL_PROVIDER_SLUG_PATTERN,\n  type ModelProviderId,\n  type ModelProviderRef,\n  modelProviderRefSchema,\n  providerIdSchema,\n  SUPPORTED_MODEL_PROVIDER_IDS,\n  type SupportedModelProviderId,\n  supportedModelProviderIdSchema,\n  UNSUPPORTED_MODEL_PROVIDER_IDS,\n} from './model-provider-id.js';\nexport {\n  type AgentRuntimeCredentialsResponseDto,\n  agentRuntimeCredentialsResponseSchema,\n} from './runtime-config.js';\nexport {\n  type SetDefaultHarnessBodyDto,\n  type SetDefaultHarnessResponseDto,\n  setDefaultHarnessBodySchema,\n  setDefaultHarnessResponseSchema,\n} from './workspace-defaults.js';\n"],"names":["agentModelOptionSchema","agentThinkingByHarness","agentThinkingSchema","claudeAgentThinkingSchema","DEFAULT_AGENT_THINKING","DEFAULT_HARNESS","DEFAULT_MODEL_PROVIDER","getModelProviderEntry","harnessSchema","listSupportedModelProviders","MODEL_PROVIDER_CATALOG_SEED","modelProviderCatalogEntrySchema","modelProviderCatalogResponseSchema","modelProviderCatalogSeedSchema","modelProviderCredentialFieldSchema","modelProviderSupportStatusSchema","piAgentThinkingSchema","thinkingLevelsForHarness","createCustomModelProviderBodySchema","customAgentModelSchema","customModelProviderConfigDtoSchema","customModelProviderHeaderDtoSchema","customModelProviderHeaderRequestSchema","customModelProviderRuntimeConfigSchema","DEFAULT_CUSTOM_MODEL_CONTEXT_WINDOW","DEFAULT_CUSTOM_MODEL_INPUT_IMAGE","DEFAULT_CUSTOM_MODEL_MAX_OUTPUT_TOKENS","DEFAULT_CUSTOM_MODEL_REASONING","discoverCustomModelProviderModelsBodySchema","discoverCustomModelProviderModelsBySlugBodySchema","discoverCustomModelProviderModelsResponseSchema","MAX_MODEL_COUNT","modelProviderApiSchema","updateCustomModelProviderBodySchema","updateCustomModelProviderHeaderRequestSchema","buildHarnessToolDeploymentConfig","CLAUDE_HARNESS","DEFAULT_HARNESS_TOOL_DEPLOYMENT_CONFIG","DEFAULT_PI_ENABLED_TOOL_PACKAGES","DEFAULT_PI_WEB_SEARCH_ENABLED","getHarnessDescriptor","getHarnessToolDescriptor","HARNESS_TOOL_PACKAGE_NAMES","harnessSupportsProvider","harnessSupportsTool","listEnabledHarnessTools","listHarnessDescriptors","listHarnessTools","PI_HARNESS","PI_HARNESS_TOOL_PACKAGE_NAMES","parsePiEnabledToolPackages","AGENT_INTEGRATION_MCP_AUTH","AGENT_INTEGRATION_MCP_ENDPOINT","AGENT_INTEGRATION_MCP_SERVER_NAME","AGENT_INTEGRATION_MCP_TRANSPORT","agentIntegrationMcpServerSchema","materializedAgentIntegrationSchema","materializedAgentIntegrationToolSchema","materializedAgentStepConfigSchema","getModelProviderCredentialKeys","listModelProviderConfigsResponseSchema","modelProviderConfigDtoSchema","modelProviderConfigResponseSchema","modelProviderCredentialKeysMatch","setDefaultModelProviderBodySchema","setDefaultModelProviderResponseSchema","updateModelProviderConfigBodySchema","updateModelProviderDefaultModelBodySchema","isReservedModelProviderId","MODEL_PROVIDER_IDS","MODEL_PROVIDER_SLUG_PATTERN","modelProviderRefSchema","providerIdSchema","SUPPORTED_MODEL_PROVIDER_IDS","supportedModelProviderIdSchema","UNSUPPORTED_MODEL_PROVIDER_IDS","agentRuntimeCredentialsResponseSchema","setDefaultHarnessBodySchema","setDefaultHarnessResponseSchema"],"mappings":"AAAA,SAGEA,sBAAsB,EACtBC,sBAAsB,EACtBC,mBAAmB,EACnBC,yBAAyB,EACzBC,sBAAsB,EACtBC,eAAe,EACfC,sBAAsB,EACtBC,qBAAqB,EAErBC,aAAa,EACbC,2BAA2B,EAC3BC,2BAA2B,EAM3BC,+BAA+B,EAC/BC,kCAAkC,EAClCC,8BAA8B,EAC9BC,kCAAkC,EAClCC,gCAAgC,EAChCC,qBAAqB,EACrBC,wBAAwB,QACnB,eAAe;AACtB,SAOEC,mCAAmC,EACnCC,sBAAsB,EACtBC,kCAAkC,EAClCC,kCAAkC,EAClCC,sCAAsC,EACtCC,sCAAsC,EACtCC,mCAAmC,EACnCC,gCAAgC,EAChCC,sCAAsC,EACtCC,8BAA8B,EAI9BC,2CAA2C,EAC3CC,iDAAiD,EACjDC,+CAA+C,EAC/CC,eAAe,EAEfC,sBAAsB,EAGtBC,mCAAmC,EACnCC,4CAA4C,QACvC,6BAA6B;AACpC,SACEC,gCAAgC,EAChCC,cAAc,EACdC,sCAAsC,EACtCC,gCAAgC,EAChCC,6BAA6B,EAC7BC,oBAAoB,EACpBC,wBAAwB,EACxBC,0BAA0B,EAK1BC,uBAAuB,EACvBC,mBAAmB,EACnBC,uBAAuB,EACvBC,sBAAsB,EACtBC,gBAAgB,EAChBC,UAAU,EACVC,6BAA6B,EAC7BC,0BAA0B,QACrB,eAAe;AACtB,SACEC,0BAA0B,EAC1BC,8BAA8B,EAC9BC,iCAAiC,EACjCC,+BAA+B,EAE/BC,+BAA+B,EAI/BC,kCAAkC,EAClCC,sCAAsC,EACtCC,iCAAiC,QAC5B,sCAAsC;AAC7C,SACEC,8BAA8B,EAE9BC,sCAAsC,EAGtCC,4BAA4B,EAC5BC,iCAAiC,EACjCC,gCAAgC,EAGhCC,iCAAiC,EACjCC,qCAAqC,EAGrCC,mCAAmC,EACnCC,yCAAyC,QACpC,6BAA6B;AACpC,SACEC,yBAAyB,EACzBC,kBAAkB,EAClBC,2BAA2B,EAG3BC,sBAAsB,EACtBC,gBAAgB,EAChBC,4BAA4B,EAE5BC,8BAA8B,EAC9BC,8BAA8B,QACzB,yBAAyB;AAChC,SAEEC,qCAAqC,QAChC,sBAAsB;AAC7B,SAGEC,2BAA2B,EAC3BC,+BAA+B,QAC1B,0BAA0B"}

package/dist/schemas/materialized-agent-step-config.d.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+export declare const materializedAgentIntegrationToolMethodSchema: z.ZodObject<{
+    id: z.ZodString;
+    token: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    sensitivity: z.ZodEnum<{
+        read: "read";
+        write: "write";
+    }>;
+    sensitive: z.ZodBoolean;
+    requiredScope: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const materializedAgentIntegrationToolSchema: z.ZodObject<{
+    id: z.ZodString;
+    sensitivity: z.ZodEnum<{
+        read: "read";
+        write: "write";
+    }>;
+    sensitive: z.ZodBoolean;
+    requiredScope: z.ZodArray<z.ZodUnknown>;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    methods: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        token: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        sensitivity: z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>;
+        sensitive: z.ZodBoolean;
+        requiredScope: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const materializedAgentIntegrationSchema: z.ZodObject<{
+    connectionId: z.ZodString;
+    connectionSlug: z.ZodString;
+    provider: z.ZodString;
+    requiredScope: z.ZodArray<z.ZodUnknown>;
+    tools: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sensitivity: z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>;
+        sensitive: z.ZodBoolean;
+        requiredScope: z.ZodArray<z.ZodUnknown>;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        methods: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            token: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            sensitivity: z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>;
+            sensitive: z.ZodBoolean;
+            requiredScope: z.ZodArray<z.ZodUnknown>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const AGENT_INTEGRATION_MCP_SERVER_NAME = "shipfox_integration_tools";
+export declare const AGENT_INTEGRATION_MCP_ENDPOINT = "/runs/jobs/current/integration-tools/mcp";
+export declare const AGENT_INTEGRATION_MCP_TRANSPORT = "http";
+export declare const AGENT_INTEGRATION_MCP_AUTH = "lease_token";
+export declare const agentIntegrationMcpServerSchema: z.ZodObject<{
+    name: z.ZodLiteral<"shipfox_integration_tools">;
+    transport: z.ZodLiteral<"http">;
+    endpoint: z.ZodLiteral<"/runs/jobs/current/integration-tools/mcp">;
+    auth: z.ZodLiteral<"lease_token">;
+    integrations: z.ZodArray<z.ZodObject<{
+        connectionId: z.ZodString;
+        connectionSlug: z.ZodString;
+        provider: z.ZodString;
+        requiredScope: z.ZodArray<z.ZodUnknown>;
+        tools: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sensitivity: z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>;
+            sensitive: z.ZodBoolean;
+            requiredScope: z.ZodArray<z.ZodUnknown>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            methods: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                token: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                sensitivity: z.ZodEnum<{
+                    read: "read";
+                    write: "write";
+                }>;
+                sensitive: z.ZodBoolean;
+                requiredScope: z.ZodArray<z.ZodUnknown>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const materializedAgentStepConfigSchema: z.ZodObject<{
+    harness: z.ZodDefault<z.ZodEnum<{
+        pi: "pi";
+        claude: "claude";
+    }>>;
+    provider: z.ZodString;
+    model: z.ZodString;
+    thinking: z.ZodEnum<{
+        off: "off";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    integrations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        connectionId: z.ZodString;
+        connectionSlug: z.ZodString;
+        provider: z.ZodString;
+        requiredScope: z.ZodArray<z.ZodUnknown>;
+        tools: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sensitivity: z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>;
+            sensitive: z.ZodBoolean;
+            requiredScope: z.ZodArray<z.ZodUnknown>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            methods: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                token: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                sensitivity: z.ZodEnum<{
+                    read: "read";
+                    write: "write";
+                }>;
+                sensitive: z.ZodBoolean;
+                requiredScope: z.ZodArray<z.ZodUnknown>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    mcpServers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodLiteral<"shipfox_integration_tools">;
+        transport: z.ZodLiteral<"http">;
+        endpoint: z.ZodLiteral<"/runs/jobs/current/integration-tools/mcp">;
+        auth: z.ZodLiteral<"lease_token">;
+        integrations: z.ZodArray<z.ZodObject<{
+            connectionId: z.ZodString;
+            connectionSlug: z.ZodString;
+            provider: z.ZodString;
+            requiredScope: z.ZodArray<z.ZodUnknown>;
+            tools: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                sensitivity: z.ZodEnum<{
+                    read: "read";
+                    write: "write";
+                }>;
+                sensitive: z.ZodBoolean;
+                requiredScope: z.ZodArray<z.ZodUnknown>;
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                methods: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    token: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    sensitivity: z.ZodEnum<{
+                        read: "read";
+                        write: "write";
+                    }>;
+                    sensitive: z.ZodBoolean;
+                    requiredScope: z.ZodArray<z.ZodUnknown>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    prompt: z.ZodString;
+}, z.core.$strip>;
+export type MaterializedAgentStepConfigDto = z.infer<typeof materializedAgentStepConfigSchema>;
+export type MaterializedAgentIntegrationConfigDto = z.infer<typeof materializedAgentIntegrationSchema>;
+export type MaterializedAgentIntegrationToolConfigDto = z.infer<typeof materializedAgentIntegrationToolSchema>;
+export type AgentIntegrationMcpServerConfigDto = z.infer<typeof agentIntegrationMcpServerSchema>;
+//# sourceMappingURL=materialized-agent-step-config.d.ts.map

package/dist/schemas/materialized-agent-step-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialized-agent-step-config.d.ts","sourceRoot":"","sources":["../../src/schemas/materialized-agent-step-config.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAOtB,eAAO,MAAM,4CAA4C;;;;;;;;;;kBAOvD,CAAC;AAEH,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;kBAQjD,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM7C,CAAC;AAEH,eAAO,MAAM,iCAAiC,8BAA8B,CAAC;AAC7E,eAAO,MAAM,8BAA8B,6CAA6C,CAAC;AACzF,eAAO,MAAM,+BAA+B,SAAS,CAAC;AACtD,eAAO,MAAM,0BAA0B,gBAAgB,CAAC;AAExD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM1C,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWpC,CAAC;AAEX,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC/F,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,kCAAkC,CAC1C,CAAC;AACF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,sCAAsC,CAC9C,CAAC;AACF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/dist/schemas/materialized-agent-step-config.js

@@ -0,0 +1,56 @@
+import { agentThinkingSchema, DEFAULT_HARNESS, harnessSchema } from '@shipfox/workflow-document';
+import { z } from 'zod';
+import { modelProviderRefSchema } from './model-provider-id.js';
+const agentToolSensitivitySchema = z.enum([
+    'read',
+    'write'
+]);
+const agentToolJsonSchema = z.record(z.string(), z.unknown());
+const agentToolRequiredScopeSchema = z.array(z.unknown());
+export const materializedAgentIntegrationToolMethodSchema = z.strictObject({
+    id: z.string().min(1),
+    token: z.string().min(1),
+    description: z.string().min(1).optional(),
+    sensitivity: agentToolSensitivitySchema,
+    sensitive: z.boolean(),
+    requiredScope: agentToolRequiredScopeSchema
+});
+export const materializedAgentIntegrationToolSchema = z.strictObject({
+    id: z.string().min(1),
+    sensitivity: agentToolSensitivitySchema,
+    sensitive: z.boolean(),
+    requiredScope: agentToolRequiredScopeSchema,
+    inputSchema: agentToolJsonSchema,
+    outputSchema: agentToolJsonSchema.optional(),
+    methods: z.array(materializedAgentIntegrationToolMethodSchema).min(1).optional()
+});
+export const materializedAgentIntegrationSchema = z.strictObject({
+    connectionId: z.string().min(1),
+    connectionSlug: z.string().min(1),
+    provider: z.string().min(1),
+    requiredScope: agentToolRequiredScopeSchema,
+    tools: z.array(materializedAgentIntegrationToolSchema).min(1)
+});
+export const AGENT_INTEGRATION_MCP_SERVER_NAME = 'shipfox_integration_tools';
+export const AGENT_INTEGRATION_MCP_ENDPOINT = '/runs/jobs/current/integration-tools/mcp';
+export const AGENT_INTEGRATION_MCP_TRANSPORT = 'http';
+export const AGENT_INTEGRATION_MCP_AUTH = 'lease_token';
+export const agentIntegrationMcpServerSchema = z.strictObject({
+    name: z.literal(AGENT_INTEGRATION_MCP_SERVER_NAME),
+    transport: z.literal(AGENT_INTEGRATION_MCP_TRANSPORT),
+    endpoint: z.literal(AGENT_INTEGRATION_MCP_ENDPOINT),
+    auth: z.literal(AGENT_INTEGRATION_MCP_AUTH),
+    integrations: z.array(materializedAgentIntegrationSchema).min(1)
+});
+export const materializedAgentStepConfigSchema = z.object({
+    harness: harnessSchema.default(DEFAULT_HARNESS),
+    provider: modelProviderRefSchema,
+    model: z.string().min(1),
+    thinking: agentThinkingSchema,
+    tools: z.array(z.string().min(1)).min(1).optional(),
+    integrations: z.array(materializedAgentIntegrationSchema).min(1).optional(),
+    mcpServers: z.array(agentIntegrationMcpServerSchema).length(1).optional(),
+    prompt: z.string()
+}).strip();
+
+//# sourceMappingURL=materialized-agent-step-config.js.map

package/dist/schemas/materialized-agent-step-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/materialized-agent-step-config.ts"],"sourcesContent":["import {agentThinkingSchema, DEFAULT_HARNESS, harnessSchema} from '@shipfox/workflow-document';\nimport {z} from 'zod';\nimport {modelProviderRefSchema} from './model-provider-id.js';\n\nconst agentToolSensitivitySchema = z.enum(['read', 'write']);\nconst agentToolJsonSchema = z.record(z.string(), z.unknown());\nconst agentToolRequiredScopeSchema = z.array(z.unknown());\n\nexport const materializedAgentIntegrationToolMethodSchema = z.strictObject({\n  id: z.string().min(1),\n  token: z.string().min(1),\n  description: z.string().min(1).optional(),\n  sensitivity: agentToolSensitivitySchema,\n  sensitive: z.boolean(),\n  requiredScope: agentToolRequiredScopeSchema,\n});\n\nexport const materializedAgentIntegrationToolSchema = z.strictObject({\n  id: z.string().min(1),\n  sensitivity: agentToolSensitivitySchema,\n  sensitive: z.boolean(),\n  requiredScope: agentToolRequiredScopeSchema,\n  inputSchema: agentToolJsonSchema,\n  outputSchema: agentToolJsonSchema.optional(),\n  methods: z.array(materializedAgentIntegrationToolMethodSchema).min(1).optional(),\n});\n\nexport const materializedAgentIntegrationSchema = z.strictObject({\n  connectionId: z.string().min(1),\n  connectionSlug: z.string().min(1),\n  provider: z.string().min(1),\n  requiredScope: agentToolRequiredScopeSchema,\n  tools: z.array(materializedAgentIntegrationToolSchema).min(1),\n});\n\nexport const AGENT_INTEGRATION_MCP_SERVER_NAME = 'shipfox_integration_tools';\nexport const AGENT_INTEGRATION_MCP_ENDPOINT = '/runs/jobs/current/integration-tools/mcp';\nexport const AGENT_INTEGRATION_MCP_TRANSPORT = 'http';\nexport const AGENT_INTEGRATION_MCP_AUTH = 'lease_token';\n\nexport const agentIntegrationMcpServerSchema = z.strictObject({\n  name: z.literal(AGENT_INTEGRATION_MCP_SERVER_NAME),\n  transport: z.literal(AGENT_INTEGRATION_MCP_TRANSPORT),\n  endpoint: z.literal(AGENT_INTEGRATION_MCP_ENDPOINT),\n  auth: z.literal(AGENT_INTEGRATION_MCP_AUTH),\n  integrations: z.array(materializedAgentIntegrationSchema).min(1),\n});\n\nexport const materializedAgentStepConfigSchema = z\n  .object({\n    harness: harnessSchema.default(DEFAULT_HARNESS),\n    provider: modelProviderRefSchema,\n    model: z.string().min(1),\n    thinking: agentThinkingSchema,\n    tools: z.array(z.string().min(1)).min(1).optional(),\n    integrations: z.array(materializedAgentIntegrationSchema).min(1).optional(),\n    mcpServers: z.array(agentIntegrationMcpServerSchema).length(1).optional(),\n    prompt: z.string(),\n  })\n  .strip();\n\nexport type MaterializedAgentStepConfigDto = z.infer<typeof materializedAgentStepConfigSchema>;\nexport type MaterializedAgentIntegrationConfigDto = z.infer<\n  typeof materializedAgentIntegrationSchema\n>;\nexport type MaterializedAgentIntegrationToolConfigDto = z.infer<\n  typeof materializedAgentIntegrationToolSchema\n>;\nexport type AgentIntegrationMcpServerConfigDto = z.infer<typeof agentIntegrationMcpServerSchema>;\n"],"names":["agentThinkingSchema","DEFAULT_HARNESS","harnessSchema","z","modelProviderRefSchema","agentToolSensitivitySchema","enum","agentToolJsonSchema","record","string","unknown","agentToolRequiredScopeSchema","array","materializedAgentIntegrationToolMethodSchema","strictObject","id","min","token","description","optional","sensitivity","sensitive","boolean","requiredScope","materializedAgentIntegrationToolSchema","inputSchema","outputSchema","methods","materializedAgentIntegrationSchema","connectionId","connectionSlug","provider","tools","AGENT_INTEGRATION_MCP_SERVER_NAME","AGENT_INTEGRATION_MCP_ENDPOINT","AGENT_INTEGRATION_MCP_TRANSPORT","AGENT_INTEGRATION_MCP_AUTH","agentIntegrationMcpServerSchema","name","literal","transport","endpoint","auth","integrations","materializedAgentStepConfigSchema","object","harness","default","model","thinking","mcpServers","length","prompt","strip"],"mappings":"AAAA,SAAQA,mBAAmB,EAAEC,eAAe,EAAEC,aAAa,QAAO,6BAA6B;AAC/F,SAAQC,CAAC,QAAO,MAAM;AACtB,SAAQC,sBAAsB,QAAO,yBAAyB;AAE9D,MAAMC,6BAA6BF,EAAEG,IAAI,CAAC;IAAC;IAAQ;CAAQ;AAC3D,MAAMC,sBAAsBJ,EAAEK,MAAM,CAACL,EAAEM,MAAM,IAAIN,EAAEO,OAAO;AAC1D,MAAMC,+BAA+BR,EAAES,KAAK,CAACT,EAAEO,OAAO;AAEtD,OAAO,MAAMG,+CAA+CV,EAAEW,YAAY,CAAC;IACzEC,IAAIZ,EAAEM,MAAM,GAAGO,GAAG,CAAC;IACnBC,OAAOd,EAAEM,MAAM,GAAGO,GAAG,CAAC;IACtBE,aAAaf,EAAEM,MAAM,GAAGO,GAAG,CAAC,GAAGG,QAAQ;IACvCC,aAAaf;IACbgB,WAAWlB,EAAEmB,OAAO;IACpBC,eAAeZ;AACjB,GAAG;AAEH,OAAO,MAAMa,yCAAyCrB,EAAEW,YAAY,CAAC;IACnEC,IAAIZ,EAAEM,MAAM,GAAGO,GAAG,CAAC;IACnBI,aAAaf;IACbgB,WAAWlB,EAAEmB,OAAO;IACpBC,eAAeZ;IACfc,aAAalB;IACbmB,cAAcnB,oBAAoBY,QAAQ;IAC1CQ,SAASxB,EAAES,KAAK,CAACC,8CAA8CG,GAAG,CAAC,GAAGG,QAAQ;AAChF,GAAG;AAEH,OAAO,MAAMS,qCAAqCzB,EAAEW,YAAY,CAAC;IAC/De,cAAc1B,EAAEM,MAAM,GAAGO,GAAG,CAAC;IAC7Bc,gBAAgB3B,EAAEM,MAAM,GAAGO,GAAG,CAAC;IAC/Be,UAAU5B,EAAEM,MAAM,GAAGO,GAAG,CAAC;IACzBO,eAAeZ;IACfqB,OAAO7B,EAAES,KAAK,CAACY,wCAAwCR,GAAG,CAAC;AAC7D,GAAG;AAEH,OAAO,MAAMiB,oCAAoC,4BAA4B;AAC7E,OAAO,MAAMC,iCAAiC,2CAA2C;AACzF,OAAO,MAAMC,kCAAkC,OAAO;AACtD,OAAO,MAAMC,6BAA6B,cAAc;AAExD,OAAO,MAAMC,kCAAkClC,EAAEW,YAAY,CAAC;IAC5DwB,MAAMnC,EAAEoC,OAAO,CAACN;IAChBO,WAAWrC,EAAEoC,OAAO,CAACJ;IACrBM,UAAUtC,EAAEoC,OAAO,CAACL;IACpBQ,MAAMvC,EAAEoC,OAAO,CAACH;IAChBO,cAAcxC,EAAES,KAAK,CAACgB,oCAAoCZ,GAAG,CAAC;AAChE,GAAG;AAEH,OAAO,MAAM4B,oCAAoCzC,EAC9C0C,MAAM,CAAC;IACNC,SAAS5C,cAAc6C,OAAO,CAAC9C;IAC/B8B,UAAU3B;IACV4C,OAAO7C,EAAEM,MAAM,GAAGO,GAAG,CAAC;IACtBiC,UAAUjD;IACVgC,OAAO7B,EAAES,KAAK,CAACT,EAAEM,MAAM,GAAGO,GAAG,CAAC,IAAIA,GAAG,CAAC,GAAGG,QAAQ;IACjDwB,cAAcxC,EAAES,KAAK,CAACgB,oCAAoCZ,GAAG,CAAC,GAAGG,QAAQ;IACzE+B,YAAY/C,EAAES,KAAK,CAACyB,iCAAiCc,MAAM,CAAC,GAAGhC,QAAQ;IACvEiC,QAAQjD,EAAEM,MAAM;AAClB,GACC4C,KAAK,GAAG"}

package/dist/schemas/model-provider-config.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import { type SupportedModelProviderId } from './model-provider-id.js';
+export declare const modelProviderConfigDtoSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"builtin">;
+    provider_id: z.ZodString;
+    default_model: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type ModelProviderConfigDto = z.infer<typeof modelProviderConfigDtoSchema>;
+export declare const modelProviderConfigResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"builtin">;
+    provider_id: z.ZodString;
+    default_model: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    api: z.ZodEnum<{
+        "openai-completions": "openai-completions";
+        "openai-responses": "openai-responses";
+        "anthropic-messages": "anthropic-messages";
+        "google-generative-ai": "google-generative-ai";
+    }>;
+    base_url: z.ZodString;
+    headers: z.ZodArray<z.ZodObject<{
+        name: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    secret_header_names: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        context_window: z.ZodOptional<z.ZodNumber>;
+        max_output_tokens: z.ZodOptional<z.ZodNumber>;
+        input_image: z.ZodOptional<z.ZodBoolean>;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    kind: z.ZodLiteral<"custom">;
+    provider_id: z.ZodString;
+    display_name: z.ZodString;
+    default_model: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type ModelProviderConfigResponseDto = z.infer<typeof modelProviderConfigResponseSchema>;
+export declare const listModelProviderConfigsResponseSchema: z.ZodObject<{
+    configs: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"builtin">;
+        provider_id: z.ZodString;
+        default_model: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        api: z.ZodEnum<{
+            "openai-completions": "openai-completions";
+            "openai-responses": "openai-responses";
+            "anthropic-messages": "anthropic-messages";
+            "google-generative-ai": "google-generative-ai";
+        }>;
+        base_url: z.ZodString;
+        headers: z.ZodArray<z.ZodObject<{
+            name: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        secret_header_names: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            context_window: z.ZodOptional<z.ZodNumber>;
+            max_output_tokens: z.ZodOptional<z.ZodNumber>;
+            input_image: z.ZodOptional<z.ZodBoolean>;
+            reasoning: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        kind: z.ZodLiteral<"custom">;
+        provider_id: z.ZodString;
+        display_name: z.ZodString;
+        default_model: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    default_provider_id: z.ZodNullable<z.ZodString>;
+    default_harness_id: z.ZodNullable<z.ZodEnum<{
+        pi: "pi";
+        claude: "claude";
+    }>>;
+}, z.core.$strip>;
+export type ListModelProviderConfigsResponseDto = z.infer<typeof listModelProviderConfigsResponseSchema>;
+export declare const updateModelProviderConfigBodySchema: z.ZodObject<{
+    default_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    credentials: z.ZodRecord<z.ZodString, z.ZodString>;
+    set_as_default: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type UpdateModelProviderConfigBodyDto = z.infer<typeof updateModelProviderConfigBodySchema>;
+export declare const updateModelProviderDefaultModelBodySchema: z.ZodObject<{
+    default_model: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type UpdateModelProviderDefaultModelBodyDto = z.infer<typeof updateModelProviderDefaultModelBodySchema>;
+export declare const setDefaultModelProviderBodySchema: z.ZodObject<{
+    provider_id: z.ZodString;
+}, z.core.$strip>;
+export type SetDefaultModelProviderBodyDto = z.infer<typeof setDefaultModelProviderBodySchema>;
+export declare const setDefaultModelProviderResponseSchema: z.ZodObject<{
+    default_provider_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SetDefaultModelProviderResponseDto = z.infer<typeof setDefaultModelProviderResponseSchema>;
+export declare function getModelProviderCredentialKeys(providerId: SupportedModelProviderId): string[] | undefined;
+export declare function modelProviderCredentialKeysMatch(providerId: SupportedModelProviderId, credentials: Record<string, string>): boolean;
+//# sourceMappingURL=model-provider-config.d.ts.map

package/dist/schemas/model-provider-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-provider-config.d.ts","sourceRoot":"","sources":["../../src/schemas/model-provider-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,EAAyB,KAAK,wBAAwB,EAAC,MAAM,wBAAwB,CAAC;AAK7F,eAAO,MAAM,4BAA4B;;;;;;iBAMvC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAG5C,CAAC;AAEH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE/F,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIjD,CAAC;AAEH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,sCAAsC,CAC9C,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;iBAM9C,CAAC;AAEH,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEnG,eAAO,MAAM,yCAAyC;;iBAEpD,CAAC;AAEH,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,yCAAyC,CACjD,CAAC;AAEF,eAAO,MAAM,iCAAiC;;iBAE5C,CAAC;AAEH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE/F,eAAO,MAAM,qCAAqC;;iBAEhD,CAAC;AAEH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CACtD,OAAO,qCAAqC,CAC7C,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,wBAAwB,GACnC,MAAM,EAAE,GAAG,SAAS,CAItB;AAED,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,wBAAwB,EACpC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,OAAO,CAIT"}

package/dist/schemas/model-provider-config.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { getModelProviderEntry, harnessSchema } from './catalog.js';
+import { customModelProviderConfigDtoSchema } from './custom-model-provider.js';
+import { modelProviderRefSchema } from './model-provider-id.js';
+const credentialKeySchema = z.string().min(1);
+const credentialRecordSchema = z.record(credentialKeySchema, z.string().min(1));
+export const modelProviderConfigDtoSchema = z.object({
+    kind: z.literal('builtin'),
+    provider_id: modelProviderRefSchema,
+    default_model: z.string().min(1).nullable(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime()
+});
+export const modelProviderConfigResponseSchema = z.discriminatedUnion('kind', [
+    modelProviderConfigDtoSchema,
+    customModelProviderConfigDtoSchema
+]);
+export const listModelProviderConfigsResponseSchema = z.object({
+    configs: z.array(modelProviderConfigResponseSchema),
+    default_provider_id: modelProviderRefSchema.nullable(),
+    default_harness_id: harnessSchema.nullable()
+});
+export const updateModelProviderConfigBodySchema = z.object({
+    default_model: z.string().min(1).nullable().optional(),
+    credentials: credentialRecordSchema.refine((credentials)=>Object.keys(credentials).length > 0, {
+        message: 'Credentials must include at least one key.'
+    }),
+    set_as_default: z.boolean().optional()
+});
+export const updateModelProviderDefaultModelBodySchema = z.object({
+    default_model: z.string().min(1).nullable()
+});
+export const setDefaultModelProviderBodySchema = z.object({
+    provider_id: modelProviderRefSchema
+});
+export const setDefaultModelProviderResponseSchema = z.object({
+    default_provider_id: modelProviderRefSchema.nullable()
+});
+export function getModelProviderCredentialKeys(providerId) {
+    const entry = getModelProviderEntry(providerId);
+    if (entry === undefined || entry.support_status !== 'supported') return undefined;
+    return entry.credential_fields.map((field)=>field.key).sort();
+}
+export function modelProviderCredentialKeysMatch(providerId, credentials) {
+    const expectedKeys = getModelProviderCredentialKeys(providerId);
+    if (expectedKeys === undefined) return false;
+    return sameKeys(Object.keys(credentials).sort(), expectedKeys);
+}
+function sameKeys(actualKeys, expectedKeys) {
+    if (actualKeys.length !== expectedKeys.length) return false;
+    return actualKeys.every((key, index)=>key === expectedKeys[index]);
+}
+
+//# sourceMappingURL=model-provider-config.js.map

package/dist/schemas/model-provider-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/model-provider-config.ts"],"sourcesContent":["import {z} from 'zod';\nimport {getModelProviderEntry, harnessSchema} from './catalog.js';\nimport {customModelProviderConfigDtoSchema} from './custom-model-provider.js';\nimport {modelProviderRefSchema, type SupportedModelProviderId} from './model-provider-id.js';\n\nconst credentialKeySchema = z.string().min(1);\nconst credentialRecordSchema = z.record(credentialKeySchema, z.string().min(1));\n\nexport const modelProviderConfigDtoSchema = z.object({\n  kind: z.literal('builtin'),\n  provider_id: modelProviderRefSchema,\n  default_model: z.string().min(1).nullable(),\n  created_at: z.string().datetime(),\n  updated_at: z.string().datetime(),\n});\n\nexport type ModelProviderConfigDto = z.infer<typeof modelProviderConfigDtoSchema>;\n\nexport const modelProviderConfigResponseSchema = z.discriminatedUnion('kind', [\n  modelProviderConfigDtoSchema,\n  customModelProviderConfigDtoSchema,\n]);\n\nexport type ModelProviderConfigResponseDto = z.infer<typeof modelProviderConfigResponseSchema>;\n\nexport const listModelProviderConfigsResponseSchema = z.object({\n  configs: z.array(modelProviderConfigResponseSchema),\n  default_provider_id: modelProviderRefSchema.nullable(),\n  default_harness_id: harnessSchema.nullable(),\n});\n\nexport type ListModelProviderConfigsResponseDto = z.infer<\n  typeof listModelProviderConfigsResponseSchema\n>;\n\nexport const updateModelProviderConfigBodySchema = z.object({\n  default_model: z.string().min(1).nullable().optional(),\n  credentials: credentialRecordSchema.refine((credentials) => Object.keys(credentials).length > 0, {\n    message: 'Credentials must include at least one key.',\n  }),\n  set_as_default: z.boolean().optional(),\n});\n\nexport type UpdateModelProviderConfigBodyDto = z.infer<typeof updateModelProviderConfigBodySchema>;\n\nexport const updateModelProviderDefaultModelBodySchema = z.object({\n  default_model: z.string().min(1).nullable(),\n});\n\nexport type UpdateModelProviderDefaultModelBodyDto = z.infer<\n  typeof updateModelProviderDefaultModelBodySchema\n>;\n\nexport const setDefaultModelProviderBodySchema = z.object({\n  provider_id: modelProviderRefSchema,\n});\n\nexport type SetDefaultModelProviderBodyDto = z.infer<typeof setDefaultModelProviderBodySchema>;\n\nexport const setDefaultModelProviderResponseSchema = z.object({\n  default_provider_id: modelProviderRefSchema.nullable(),\n});\n\nexport type SetDefaultModelProviderResponseDto = z.infer<\n  typeof setDefaultModelProviderResponseSchema\n>;\n\nexport function getModelProviderCredentialKeys(\n  providerId: SupportedModelProviderId,\n): string[] | undefined {\n  const entry = getModelProviderEntry(providerId);\n  if (entry === undefined || entry.support_status !== 'supported') return undefined;\n  return entry.credential_fields.map((field) => field.key).sort();\n}\n\nexport function modelProviderCredentialKeysMatch(\n  providerId: SupportedModelProviderId,\n  credentials: Record<string, string>,\n): boolean {\n  const expectedKeys = getModelProviderCredentialKeys(providerId);\n  if (expectedKeys === undefined) return false;\n  return sameKeys(Object.keys(credentials).sort(), expectedKeys);\n}\n\nfunction sameKeys(actualKeys: string[], expectedKeys: string[]): boolean {\n  if (actualKeys.length !== expectedKeys.length) return false;\n  return actualKeys.every((key, index) => key === expectedKeys[index]);\n}\n"],"names":["z","getModelProviderEntry","harnessSchema","customModelProviderConfigDtoSchema","modelProviderRefSchema","credentialKeySchema","string","min","credentialRecordSchema","record","modelProviderConfigDtoSchema","object","kind","literal","provider_id","default_model","nullable","created_at","datetime","updated_at","modelProviderConfigResponseSchema","discriminatedUnion","listModelProviderConfigsResponseSchema","configs","array","default_provider_id","default_harness_id","updateModelProviderConfigBodySchema","optional","credentials","refine","Object","keys","length","message","set_as_default","boolean","updateModelProviderDefaultModelBodySchema","setDefaultModelProviderBodySchema","setDefaultModelProviderResponseSchema","getModelProviderCredentialKeys","providerId","entry","undefined","support_status","credential_fields","map","field","key","sort","modelProviderCredentialKeysMatch","expectedKeys","sameKeys","actualKeys","every","index"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AACtB,SAAQC,qBAAqB,EAAEC,aAAa,QAAO,eAAe;AAClE,SAAQC,kCAAkC,QAAO,6BAA6B;AAC9E,SAAQC,sBAAsB,QAAsC,yBAAyB;AAE7F,MAAMC,sBAAsBL,EAAEM,MAAM,GAAGC,GAAG,CAAC;AAC3C,MAAMC,yBAAyBR,EAAES,MAAM,CAACJ,qBAAqBL,EAAEM,MAAM,GAAGC,GAAG,CAAC;AAE5E,OAAO,MAAMG,+BAA+BV,EAAEW,MAAM,CAAC;IACnDC,MAAMZ,EAAEa,OAAO,CAAC;IAChBC,aAAaV;IACbW,eAAef,EAAEM,MAAM,GAAGC,GAAG,CAAC,GAAGS,QAAQ;IACzCC,YAAYjB,EAAEM,MAAM,GAAGY,QAAQ;IAC/BC,YAAYnB,EAAEM,MAAM,GAAGY,QAAQ;AACjC,GAAG;AAIH,OAAO,MAAME,oCAAoCpB,EAAEqB,kBAAkB,CAAC,QAAQ;IAC5EX;IACAP;CACD,EAAE;AAIH,OAAO,MAAMmB,yCAAyCtB,EAAEW,MAAM,CAAC;IAC7DY,SAASvB,EAAEwB,KAAK,CAACJ;IACjBK,qBAAqBrB,uBAAuBY,QAAQ;IACpDU,oBAAoBxB,cAAcc,QAAQ;AAC5C,GAAG;AAMH,OAAO,MAAMW,sCAAsC3B,EAAEW,MAAM,CAAC;IAC1DI,eAAef,EAAEM,MAAM,GAAGC,GAAG,CAAC,GAAGS,QAAQ,GAAGY,QAAQ;IACpDC,aAAarB,uBAAuBsB,MAAM,CAAC,CAACD,cAAgBE,OAAOC,IAAI,CAACH,aAAaI,MAAM,GAAG,GAAG;QAC/FC,SAAS;IACX;IACAC,gBAAgBnC,EAAEoC,OAAO,GAAGR,QAAQ;AACtC,GAAG;AAIH,OAAO,MAAMS,4CAA4CrC,EAAEW,MAAM,CAAC;IAChEI,eAAef,EAAEM,MAAM,GAAGC,GAAG,CAAC,GAAGS,QAAQ;AAC3C,GAAG;AAMH,OAAO,MAAMsB,oCAAoCtC,EAAEW,MAAM,CAAC;IACxDG,aAAaV;AACf,GAAG;AAIH,OAAO,MAAMmC,wCAAwCvC,EAAEW,MAAM,CAAC;IAC5Dc,qBAAqBrB,uBAAuBY,QAAQ;AACtD,GAAG;AAMH,OAAO,SAASwB,+BACdC,UAAoC;IAEpC,MAAMC,QAAQzC,sBAAsBwC;IACpC,IAAIC,UAAUC,aAAaD,MAAME,cAAc,KAAK,aAAa,OAAOD;IACxE,OAAOD,MAAMG,iBAAiB,CAACC,GAAG,CAAC,CAACC,QAAUA,MAAMC,GAAG,EAAEC,IAAI;AAC/D;AAEA,OAAO,SAASC,iCACdT,UAAoC,EACpCZ,WAAmC;IAEnC,MAAMsB,eAAeX,+BAA+BC;IACpD,IAAIU,iBAAiBR,WAAW,OAAO;IACvC,OAAOS,SAASrB,OAAOC,IAAI,CAACH,aAAaoB,IAAI,IAAIE;AACnD;AAEA,SAASC,SAASC,UAAoB,EAAEF,YAAsB;IAC5D,IAAIE,WAAWpB,MAAM,KAAKkB,aAAalB,MAAM,EAAE,OAAO;IACtD,OAAOoB,WAAWC,KAAK,CAAC,CAACN,KAAKO,QAAUP,QAAQG,YAAY,CAACI,MAAM;AACrE"}

package/dist/schemas/model-provider-id.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export declare const SUPPORTED_MODEL_PROVIDER_IDS: readonly ["anthropic", "ant-ling", "azure-openai-responses", "openai", "deepseek", "nvidia", "google", "mistral", "groq", "cerebras", "cloudflare-ai-gateway", "cloudflare-workers-ai", "xai", "openrouter", "vercel-ai-gateway", "zai", "zai-coding-cn", "opencode", "opencode-go", "huggingface", "fireworks", "together", "kimi-coding", "minimax", "minimax-cn", "moonshotai", "moonshotai-cn", "xiaomi", "xiaomi-token-plan-cn", "xiaomi-token-plan-ams", "xiaomi-token-plan-sgp"];
+export declare const UNSUPPORTED_MODEL_PROVIDER_IDS: readonly ["amazon-bedrock", "google-vertex", "openai-codex", "github-copilot"];
+export declare const MODEL_PROVIDER_IDS: readonly ["anthropic", "ant-ling", "azure-openai-responses", "openai", "deepseek", "nvidia", "google", "mistral", "groq", "cerebras", "cloudflare-ai-gateway", "cloudflare-workers-ai", "xai", "openrouter", "vercel-ai-gateway", "zai", "zai-coding-cn", "opencode", "opencode-go", "huggingface", "fireworks", "together", "kimi-coding", "minimax", "minimax-cn", "moonshotai", "moonshotai-cn", "xiaomi", "xiaomi-token-plan-cn", "xiaomi-token-plan-ams", "xiaomi-token-plan-sgp", "amazon-bedrock", "google-vertex", "openai-codex", "github-copilot"];
+export declare const supportedModelProviderIdSchema: z.ZodEnum<{
+    anthropic: "anthropic";
+    "ant-ling": "ant-ling";
+    "azure-openai-responses": "azure-openai-responses";
+    openai: "openai";
+    deepseek: "deepseek";
+    nvidia: "nvidia";
+    google: "google";
+    mistral: "mistral";
+    groq: "groq";
+    cerebras: "cerebras";
+    "cloudflare-ai-gateway": "cloudflare-ai-gateway";
+    "cloudflare-workers-ai": "cloudflare-workers-ai";
+    xai: "xai";
+    openrouter: "openrouter";
+    "vercel-ai-gateway": "vercel-ai-gateway";
+    zai: "zai";
+    "zai-coding-cn": "zai-coding-cn";
+    opencode: "opencode";
+    "opencode-go": "opencode-go";
+    huggingface: "huggingface";
+    fireworks: "fireworks";
+    together: "together";
+    "kimi-coding": "kimi-coding";
+    minimax: "minimax";
+    "minimax-cn": "minimax-cn";
+    moonshotai: "moonshotai";
+    "moonshotai-cn": "moonshotai-cn";
+    xiaomi: "xiaomi";
+    "xiaomi-token-plan-cn": "xiaomi-token-plan-cn";
+    "xiaomi-token-plan-ams": "xiaomi-token-plan-ams";
+    "xiaomi-token-plan-sgp": "xiaomi-token-plan-sgp";
+}>;
+export declare const providerIdSchema: z.ZodEnum<{
+    anthropic: "anthropic";
+    "ant-ling": "ant-ling";
+    "azure-openai-responses": "azure-openai-responses";
+    openai: "openai";
+    deepseek: "deepseek";
+    nvidia: "nvidia";
+    google: "google";
+    mistral: "mistral";
+    groq: "groq";
+    cerebras: "cerebras";
+    "cloudflare-ai-gateway": "cloudflare-ai-gateway";
+    "cloudflare-workers-ai": "cloudflare-workers-ai";
+    xai: "xai";
+    openrouter: "openrouter";
+    "vercel-ai-gateway": "vercel-ai-gateway";
+    zai: "zai";
+    "zai-coding-cn": "zai-coding-cn";
+    opencode: "opencode";
+    "opencode-go": "opencode-go";
+    huggingface: "huggingface";
+    fireworks: "fireworks";
+    together: "together";
+    "kimi-coding": "kimi-coding";
+    minimax: "minimax";
+    "minimax-cn": "minimax-cn";
+    moonshotai: "moonshotai";
+    "moonshotai-cn": "moonshotai-cn";
+    xiaomi: "xiaomi";
+    "xiaomi-token-plan-cn": "xiaomi-token-plan-cn";
+    "xiaomi-token-plan-ams": "xiaomi-token-plan-ams";
+    "xiaomi-token-plan-sgp": "xiaomi-token-plan-sgp";
+    "amazon-bedrock": "amazon-bedrock";
+    "google-vertex": "google-vertex";
+    "openai-codex": "openai-codex";
+    "github-copilot": "github-copilot";
+}>;
+export declare const MODEL_PROVIDER_SLUG_PATTERN: RegExp;
+export declare const modelProviderRefSchema: z.ZodString;
+export type SupportedModelProviderId = z.infer<typeof supportedModelProviderIdSchema>;
+export type ModelProviderId = z.infer<typeof providerIdSchema>;
+export type ModelProviderRef = z.infer<typeof modelProviderRefSchema>;
+export declare function isReservedModelProviderId(value: string): boolean;
+//# sourceMappingURL=model-provider-id.d.ts.map

package/dist/schemas/model-provider-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-provider-id.d.ts","sourceRoot":"","sources":["../../src/schemas/model-provider-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,4BAA4B,ydAgC/B,CAAC;AAEX,eAAO,MAAM,8BAA8B,gFAKjC,CAAC;AAEX,eAAO,MAAM,kBAAkB,8hBAGrB,CAAC;AAEX,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAuC,CAAC;AACnF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA6B,CAAC;AAC3D,eAAO,MAAM,2BAA2B,QAAsC,CAAC;AAC/E,eAAO,MAAM,sBAAsB,aAAgD,CAAC;AAEpF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEhE"}

package/dist/schemas/model-provider-id.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export const SUPPORTED_MODEL_PROVIDER_IDS = [
+    'anthropic',
+    'ant-ling',
+    'azure-openai-responses',
+    'openai',
+    'deepseek',
+    'nvidia',
+    'google',
+    'mistral',
+    'groq',
+    'cerebras',
+    'cloudflare-ai-gateway',
+    'cloudflare-workers-ai',
+    'xai',
+    'openrouter',
+    'vercel-ai-gateway',
+    'zai',
+    'zai-coding-cn',
+    'opencode',
+    'opencode-go',
+    'huggingface',
+    'fireworks',
+    'together',
+    'kimi-coding',
+    'minimax',
+    'minimax-cn',
+    'moonshotai',
+    'moonshotai-cn',
+    'xiaomi',
+    'xiaomi-token-plan-cn',
+    'xiaomi-token-plan-ams',
+    'xiaomi-token-plan-sgp'
+];
+export const UNSUPPORTED_MODEL_PROVIDER_IDS = [
+    'amazon-bedrock',
+    'google-vertex',
+    'openai-codex',
+    'github-copilot'
+];
+export const MODEL_PROVIDER_IDS = [
+    ...SUPPORTED_MODEL_PROVIDER_IDS,
+    ...UNSUPPORTED_MODEL_PROVIDER_IDS
+];
+export const supportedModelProviderIdSchema = z.enum(SUPPORTED_MODEL_PROVIDER_IDS);
+export const providerIdSchema = z.enum(MODEL_PROVIDER_IDS);
+export const MODEL_PROVIDER_SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/;
+export const modelProviderRefSchema = z.string().regex(MODEL_PROVIDER_SLUG_PATTERN);
+export function isReservedModelProviderId(value) {
+    return MODEL_PROVIDER_IDS.includes(value);
+}
+
+//# sourceMappingURL=model-provider-id.js.map

package/dist/schemas/model-provider-id.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/model-provider-id.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const SUPPORTED_MODEL_PROVIDER_IDS = [\n  'anthropic',\n  'ant-ling',\n  'azure-openai-responses',\n  'openai',\n  'deepseek',\n  'nvidia',\n  'google',\n  'mistral',\n  'groq',\n  'cerebras',\n  'cloudflare-ai-gateway',\n  'cloudflare-workers-ai',\n  'xai',\n  'openrouter',\n  'vercel-ai-gateway',\n  'zai',\n  'zai-coding-cn',\n  'opencode',\n  'opencode-go',\n  'huggingface',\n  'fireworks',\n  'together',\n  'kimi-coding',\n  'minimax',\n  'minimax-cn',\n  'moonshotai',\n  'moonshotai-cn',\n  'xiaomi',\n  'xiaomi-token-plan-cn',\n  'xiaomi-token-plan-ams',\n  'xiaomi-token-plan-sgp',\n] as const;\n\nexport const UNSUPPORTED_MODEL_PROVIDER_IDS = [\n  'amazon-bedrock',\n  'google-vertex',\n  'openai-codex',\n  'github-copilot',\n] as const;\n\nexport const MODEL_PROVIDER_IDS = [\n  ...SUPPORTED_MODEL_PROVIDER_IDS,\n  ...UNSUPPORTED_MODEL_PROVIDER_IDS,\n] as const;\n\nexport const supportedModelProviderIdSchema = z.enum(SUPPORTED_MODEL_PROVIDER_IDS);\nexport const providerIdSchema = z.enum(MODEL_PROVIDER_IDS);\nexport const MODEL_PROVIDER_SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$/;\nexport const modelProviderRefSchema = z.string().regex(MODEL_PROVIDER_SLUG_PATTERN);\n\nexport type SupportedModelProviderId = z.infer<typeof supportedModelProviderIdSchema>;\nexport type ModelProviderId = z.infer<typeof providerIdSchema>;\nexport type ModelProviderRef = z.infer<typeof modelProviderRefSchema>;\n\nexport function isReservedModelProviderId(value: string): boolean {\n  return (MODEL_PROVIDER_IDS as readonly string[]).includes(value);\n}\n"],"names":["z","SUPPORTED_MODEL_PROVIDER_IDS","UNSUPPORTED_MODEL_PROVIDER_IDS","MODEL_PROVIDER_IDS","supportedModelProviderIdSchema","enum","providerIdSchema","MODEL_PROVIDER_SLUG_PATTERN","modelProviderRefSchema","string","regex","isReservedModelProviderId","value","includes"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,OAAO,MAAMC,+BAA+B;IAC1C;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD,CAAU;AAEX,OAAO,MAAMC,iCAAiC;IAC5C;IACA;IACA;IACA;CACD,CAAU;AAEX,OAAO,MAAMC,qBAAqB;OAC7BF;OACAC;CACJ,CAAU;AAEX,OAAO,MAAME,iCAAiCJ,EAAEK,IAAI,CAACJ,8BAA8B;AACnF,OAAO,MAAMK,mBAAmBN,EAAEK,IAAI,CAACF,oBAAoB;AAC3D,OAAO,MAAMI,8BAA8B,oCAAoC;AAC/E,OAAO,MAAMC,yBAAyBR,EAAES,MAAM,GAAGC,KAAK,CAACH,6BAA6B;AAMpF,OAAO,SAASI,0BAA0BC,KAAa;IACrD,OAAO,AAACT,mBAAyCU,QAAQ,CAACD;AAC5D"}