@salesforce/sfdx-agent-sdk 0.21.0 → 0.22.0

package/dist/harness/stream-input.js

@@ -2,7 +2,6 @@
  * Copyright 2026, Salesforce, Inc. All rights reserved.
  * See LICENSE.txt for license terms.
  */
-import { LLMGClientError } from '@salesforce/llm-gateway-sdk';
 import { AgentSDKError, AgentSDKErrorType } from '../errors.js';
 /**
  * Shared `MessagePart[]` validation + lowering for `AgentHarness.stream()` implementations. Every
@@ -13,8 +12,10 @@ import { AgentSDKError, AgentSDKErrorType } from '../errors.js';
  *
  * Order of operations:
  *   1. Collect `image` / `file` parts into a {@link MultimodalFile} list and hand them to
- *      `validateFiles` (per-model + global gateway caps). An {@link LLMGClientError} is mapped to
- *      `AgentSDKError(MULTIMODAL_NOT_SUPPORTED)`; any other throw propagates unchanged.
+ *      `validateFiles` (per-model + global gateway caps). The standard
+ *      {@link validateMultimodalFiles} helper throws
+ *      `AgentSDKError(MULTIMODAL_NOT_SUPPORTED)` directly on a cap/format violation; any other
+ *      throw propagates unchanged.
  *   2. Lower each part via `mapPart`. A `reasoning` / `tool-call` / `tool-result` part is not valid
  *      stream input and throws `AgentSDKError(INVALID_MESSAGE_CONTENT)` before `mapPart` sees it.
  *
@@ -23,8 +24,10 @@ import { AgentSDKError, AgentSDKErrorType } from '../errors.js';
  * failure rejects the harness's `stream()` promise pre-stream rather than mid-iteration.
  *
  * @param parts - the user message parts to validate and lower.
- * @param validateFiles - per-harness file validation (e.g. `validateMultimodalFiles(files, model)`)
- *   that throws `LLMGClientError` on a cap/format violation and no-ops for text-only input.
+ * @param validateFiles - per-harness file validation (typically
+ *   `(files) => validateMultimodalFiles(files, model)`) that throws
+ *   `AgentSDKError(MULTIMODAL_NOT_SUPPORTED)` on a cap/format violation and no-ops for text-only
+ *   input.
  * @param mapPart - lowers one validated input part into the harness's content-block shape.
  * @returns the lowered blocks, in the original part order.
  */
@@ -35,15 +38,10 @@ export function lowerStreamInput(parts, validateFiles, mapPart) {
             files.push({ mimeType: part.mimeType, data: part.data });
         }
     }
-    try {
-        validateFiles(files);
-    }
-    catch (err) {
-        if (err instanceof LLMGClientError) {
-            throw new AgentSDKError(err.message, AgentSDKErrorType.MULTIMODAL_NOT_SUPPORTED, { cause: err });
-        }
-        throw err;
-    }
+    // validateFiles is expected to throw AgentSDKError(MULTIMODAL_NOT_SUPPORTED) directly
+    // on a cap/format violation; harnesses pass `validateMultimodalFiles(files, model)`
+    // from this package, which already throws the typed error. Other throws propagate.
+    validateFiles(files);
     return parts.map((part) => {
         if (part.type === 'text' || part.type === 'image' || part.type === 'file') {
             return mapPart(part);

package/dist/index.d.ts

@@ -7,17 +7,23 @@ export type { AgentConfig, HarnessAgentConfig, StreamOptions, ToolApprovalMode }
 export { DEFAULT_MAX_STEPS, resolveToolApprovalMode } from './harness/harness-config.js';
 export type { MCPConfiguration, MCPServerConfig, MCPStdioServerConfig, MCPRemoteServerConfig, McpServerInfo, McpServerErrorCategory, McpServerErrorDetail, McpToolInfo, McpToolAnnotations, } from './mcp-config.js';
 export { McpServerStatus, mcpServerConfigEqual } from './mcp-config.js';
-export { Model, ModelName, createClaudeModel } from '@salesforce/llm-gateway-sdk';
-export type { ClaudeModelOverrides } from '@salesforce/llm-gateway-sdk';
+export { Model, ModelName, createClaudeModel, Models, validateMultimodalFiles } from './models/index.js';
+export type { ClaudeModelOverrides, MultimodalFile, SupportedFileFormat } from './models/index.js';
+export { MimeType } from './models/index.js';
 export { inferSfApiEnv, SfApiEnv } from '@salesforce/agentic-common';
 export { type AgentManager, type RestoreFailure, createAgentManager } from './agent-manager.js';
 export { type Agent } from './agent.js';
 export { type ChatSession, type ChatOptions } from './chat-session.js';
 export type { AgentConnectivityResolver, ResolvedConnectivity } from './agent-connectivity-resolver.js';
+export { ApiKeyConnectivityResolver, type ApiKeyConnectivityResolverConfig } from './api-key-connectivity-resolver.js';
+export type { ModelConnectivityInfo, ProviderHint } from './types/model-connectivity-info.js';
+export type { LlmRequestEvent, LlmResponseEvent, WireCommunicationEvent, WireCommunicationEventCallback, WireMonitoringNotSupportedEvent, } from './types/wire-communication-event.js';
+export { WireCommunicationFileWriter, type WireCommunicationEmitter, type WireCommunicationFileWriterOptions, } from './wire-communication-file-writer.js';
 export type { AgentHarness, HarnessFactory, WithAgentConfig, ConfigOf } from './harness/index.js';
 export { AgentSDKError, AgentSDKErrorType } from './errors.js';
 export type { AgentCreatedEvent, AgentDestroyedEvent, ChatStreamCompletedEvent, ChatStreamErrorEvent, ChatStreamStartedEvent, ChatStreamTrigger, McpServerDiscoveryCompletedEvent, McpServerDiscoveryFailedEvent, McpServerDiscoveryStartedEvent, McpServerStatusChangedEvent, SessionCreatedEvent, SessionDestroyedEvent, TelemetryEvent, TelemetryEventCallback, ToolApprovalRequestedEvent, ToolApprovalResolvedEvent, ToolExecutionCompletedEvent, ToolExecutionStartedEvent, } from './types/telemetry-events.js';
 export type { LogLevel, LogRecord, Unsubscribe } from '@salesforce/agentic-common';
 export { resolveMcpServerHeaders } from './mcp-auth.js';
 export type { OrgConnection, OrgConnectionFactory } from '@salesforce/agentic-common';
+export type { JSONWebToken, JWTOptions, RequiredJWTHeaders, RequiredJWTPayload } from '@salesforce/agentic-common';
 export { Workspace } from './workspace.js';

package/dist/index.js

@@ -4,12 +4,15 @@
  */
 export { DEFAULT_MAX_STEPS, resolveToolApprovalMode } from './harness/harness-config.js';
 export { McpServerStatus, mcpServerConfigEqual } from './mcp-config.js';
-export { Model, ModelName, createClaudeModel } from '@salesforce/llm-gateway-sdk';
+export { Model, ModelName, createClaudeModel, Models, validateMultimodalFiles } from './models/index.js';
+export { MimeType } from './models/index.js';
 export { inferSfApiEnv, SfApiEnv } from '@salesforce/agentic-common';
 // ── Agent Layer ─────────────────────────────────────────────────────
 export { createAgentManager } from './agent-manager.js';
 export {} from './agent.js';
 export {} from './chat-session.js';
+export { ApiKeyConnectivityResolver } from './api-key-connectivity-resolver.js';
+export { WireCommunicationFileWriter, } from './wire-communication-file-writer.js';
 // ── Errors ───────────────────────────────────────────────────────────
 export { AgentSDKError, AgentSDKErrorType } from './errors.js';
 // ── MCP Auth ────────────────────────────────────────────────────────

package/dist/internal/wire-communication-router.d.ts

@@ -0,0 +1,43 @@
+import { EventBus } from '@salesforce/agentic-common';
+import type { AgentHarness } from '../harness/agent-harness.js';
+import type { WireCommunicationEvent } from '../types/wire-communication-event.js';
+/**
+ * A wire-communication bus scoped to a single agent, session, or the unrouted
+ * catch-all.
+ *
+ * Mirrors {@link TelemetrySlice} from `telemetry-router.ts` — `DefaultAgent`
+ * and `DefaultChatSession` receive their slice at construction time and
+ * wire `forwardTo()` from the slice bus into their own bus so wire events
+ * bubble upward through the hierarchy.
+ */
+export type WireCommunicationSlice = {
+    readonly wire: EventBus<WireCommunicationEvent>;
+};
+/**
+ * Splits a harness's wire-communication stream into per-agent, per-session,
+ * and unrouted sub-streams. The shape mirrors {@link TelemetryRouter} so the
+ * three event channels (telemetry / log / wire-communication) all route
+ * through the same per-`agentId` / per-`threadId` keys.
+ *
+ * Wire-communication events do not currently carry routing fields on their
+ * public shape (the wire surface is kept minimal), so the harness is
+ * responsible for emitting the right event-pair on a slice that knows its
+ * agentId / threadId. This is the same pattern as `TelemetryRouter` for log
+ * records routed via `context.agentId` / `context.threadId`.
+ */
+export declare class WireCommunicationRouter {
+    private readonly agentSlices;
+    private readonly sessionSlices;
+    private readonly unroutedSlice;
+    private readonly harnessUnsubs;
+    private disposed;
+    constructor(harness: Pick<AgentHarness, 'onWireCommunication'>);
+    get unrouted(): WireCommunicationSlice;
+    registerAgent(agentId: string): WireCommunicationSlice;
+    unregisterAgent(agentId: string): void;
+    registerSession(threadId: string): WireCommunicationSlice;
+    unregisterSession(threadId: string): void;
+    dispose(): void;
+    private routeEvent;
+    private static createSlice;
+}

package/dist/internal/wire-communication-router.js

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { EventBus } from '@salesforce/agentic-common';
+/**
+ * Splits a harness's wire-communication stream into per-agent, per-session,
+ * and unrouted sub-streams. The shape mirrors {@link TelemetryRouter} so the
+ * three event channels (telemetry / log / wire-communication) all route
+ * through the same per-`agentId` / per-`threadId` keys.
+ *
+ * Wire-communication events do not currently carry routing fields on their
+ * public shape (the wire surface is kept minimal), so the harness is
+ * responsible for emitting the right event-pair on a slice that knows its
+ * agentId / threadId. This is the same pattern as `TelemetryRouter` for log
+ * records routed via `context.agentId` / `context.threadId`.
+ */
+export class WireCommunicationRouter {
+    agentSlices = new Map();
+    sessionSlices = new Map();
+    unroutedSlice;
+    harnessUnsubs = [];
+    disposed = false;
+    constructor(harness) {
+        this.unroutedSlice = WireCommunicationRouter.createSlice();
+        // Lazy bridge from the harness bus into the router's unrouted slice. We only attach the
+        // upstream `onWireCommunication` subscription while the slice has at least one downstream
+        // listener, and detach when it loses its last. Combined with the slice's own
+        // `forwardWhileSubscribed` link into `manager.wireBus`, this propagates
+        // "no consumer anywhere downstream" all the way back to the harness — the Claude harness
+        // reads `wireBus.listenerCount > 0` before each subprocess spawn and skips the expensive
+        // `ANTHROPIC_LOG=debug` env when nobody is listening.
+        let upstreamUnsub;
+        const attachUpstream = () => {
+            if (!upstreamUnsub) {
+                upstreamUnsub = harness.onWireCommunication((event) => this.routeEvent(event));
+            }
+        };
+        const detachUpstream = () => {
+            if (upstreamUnsub) {
+                upstreamUnsub();
+                upstreamUnsub = undefined;
+            }
+        };
+        const presenceUnsub = this.unroutedSlice.wire.onSubscriberPresenceChange((hasSubscribers) => {
+            if (hasSubscribers)
+                attachUpstream();
+            else
+                detachUpstream();
+        });
+        if (this.unroutedSlice.wire.listenerCount > 0) {
+            attachUpstream();
+        }
+        this.harnessUnsubs.push(presenceUnsub, () => detachUpstream());
+    }
+    get unrouted() {
+        return this.unroutedSlice;
+    }
+    registerAgent(agentId) {
+        let slice = this.agentSlices.get(agentId);
+        if (!slice) {
+            slice = WireCommunicationRouter.createSlice();
+            this.agentSlices.set(agentId, slice);
+        }
+        return slice;
+    }
+    unregisterAgent(agentId) {
+        const slice = this.agentSlices.get(agentId);
+        if (slice) {
+            slice.wire.dispose();
+            this.agentSlices.delete(agentId);
+        }
+    }
+    registerSession(threadId) {
+        let slice = this.sessionSlices.get(threadId);
+        if (!slice) {
+            slice = WireCommunicationRouter.createSlice();
+            this.sessionSlices.set(threadId, slice);
+        }
+        return slice;
+    }
+    unregisterSession(threadId) {
+        const slice = this.sessionSlices.get(threadId);
+        if (slice) {
+            slice.wire.dispose();
+            this.sessionSlices.delete(threadId);
+        }
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const unsub of this.harnessUnsubs)
+            unsub();
+        this.harnessUnsubs.length = 0;
+        for (const slice of this.agentSlices.values())
+            slice.wire.dispose();
+        this.agentSlices.clear();
+        for (const slice of this.sessionSlices.values())
+            slice.wire.dispose();
+        this.sessionSlices.clear();
+        this.unroutedSlice.wire.dispose();
+    }
+    routeEvent(event) {
+        if (this.disposed)
+            return;
+        // Public WireCommunicationEvent currently has no routing fields. Until
+        // that changes, every event lands on the unrouted slice; the
+        // manager-level subscriber sees them. Per-agent / per-session routing
+        // is plumbed for forward-compat — adding routing fields to the event
+        // shape in a future change lights up the per-slice paths without
+        // touching consumers.
+        this.unroutedSlice.wire.emit(event);
+    }
+    static createSlice() {
+        return { wire: new EventBus() };
+    }
+}
+//# sourceMappingURL=wire-communication-router.js.map

package/dist/mcp-auth.d.ts

@@ -1,4 +1,4 @@
-import type { JSONWebToken } from '@salesforce/llm-gateway-sdk';
+import type { JSONWebToken } from '@salesforce/agentic-common';
 /**
  * Returns true if the URL matches a Salesforce Hosted MCP Server endpoint.
  * Covers all environments (prod, dev, test, perf, stage) and all API versions

package/dist/models/claude-opus-4-5.d.ts

@@ -0,0 +1,11 @@
+import { Model, ModelName } from './model.js';
+import { type SupportedFileFormat } from './types.js';
+export declare class ClaudeOpus45 extends Model {
+    readonly name: ModelName;
+    readonly displayId: string;
+    readonly maxInputTokens: number;
+    readonly maxOutputTokens: number;
+    readonly contextWindow: number;
+    readonly supportsPromptCache: boolean;
+    readonly supportedFormats: readonly SupportedFileFormat[];
+}

package/dist/models/claude-opus-4-5.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { Model, ModelName } from './model.js';
+import { MimeType } from './types.js';
+export class ClaudeOpus45 extends Model {
+    name = ModelName.CLAUDE_OPUS_4_5;
+    displayId = 'Claude Opus 4.5';
+    maxInputTokens = 200000;
+    // 64K — 4× the Sonnet 4.6 ceiling. Anthropic raised the cap on Opus 4.5 explicitly.
+    maxOutputTokens = 64000;
+    contextWindow = 200000;
+    supportsPromptCache = true;
+    supportedFormats = [
+        { name: 'png', mimeType: MimeType.Png, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'jpeg', mimeType: MimeType.Jpeg, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'pdf', mimeType: MimeType.Pdf, maxBytesPerFile: 4.5 * 1024 * 1024, maxFilesPerRequest: 5 },
+    ];
+}
+//# sourceMappingURL=claude-opus-4-5.js.map

package/dist/models/claude-opus-4-6.d.ts

@@ -0,0 +1,11 @@
+import { Model, ModelName } from './model.js';
+import { type SupportedFileFormat } from './types.js';
+export declare class ClaudeOpus46 extends Model {
+    readonly name: ModelName;
+    readonly displayId: string;
+    readonly maxInputTokens: number;
+    readonly maxOutputTokens: number;
+    readonly contextWindow: number;
+    readonly supportsPromptCache: boolean;
+    readonly supportedFormats: readonly SupportedFileFormat[];
+}

package/dist/models/claude-opus-4-6.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { Model, ModelName } from './model.js';
+import { MimeType } from './types.js';
+export class ClaudeOpus46 extends Model {
+    name = ModelName.CLAUDE_OPUS_4_6;
+    displayId = 'Claude Opus 4.6';
+    // Caps sourced from the LLM Gateway model registry:
+    // git.soma.salesforce.com/a360/file-metadata/.../bedrock/llmgateway/BedrockAnthropicClaude46Opus.yml
+    maxInputTokens = 1_000_000;
+    maxOutputTokens = 128_000;
+    contextWindow = 1_000_000;
+    supportsPromptCache = true;
+    supportedFormats = [
+        { name: 'png', mimeType: MimeType.Png, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'jpeg', mimeType: MimeType.Jpeg, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'pdf', mimeType: MimeType.Pdf, maxBytesPerFile: 4.5 * 1024 * 1024, maxFilesPerRequest: 5 },
+    ];
+}
+//# sourceMappingURL=claude-opus-4-6.js.map

package/dist/models/claude-opus-4-7.d.ts

@@ -0,0 +1,11 @@
+import { Model, ModelName } from './model.js';
+import { type SupportedFileFormat } from './types.js';
+export declare class ClaudeOpus47 extends Model {
+    readonly name: ModelName;
+    readonly displayId: string;
+    readonly maxInputTokens: number;
+    readonly maxOutputTokens: number;
+    readonly contextWindow: number;
+    readonly supportsPromptCache: boolean;
+    readonly supportedFormats: readonly SupportedFileFormat[];
+}

package/dist/models/claude-opus-4-7.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { Model, ModelName } from './model.js';
+import { MimeType } from './types.js';
+export class ClaudeOpus47 extends Model {
+    name = ModelName.CLAUDE_OPUS_4_7;
+    displayId = 'Claude Opus 4.7';
+    // Caps sourced from the LLM Gateway model registry:
+    // git.soma.salesforce.com/a360/file-metadata/.../bedrock/llmgateway/BedrockAnthropicClaude47Opus.yml
+    maxInputTokens = 1_000_000;
+    maxOutputTokens = 128_000;
+    contextWindow = 1_000_000;
+    supportsPromptCache = true;
+    supportedFormats = [
+        { name: 'png', mimeType: MimeType.Png, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'jpeg', mimeType: MimeType.Jpeg, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'pdf', mimeType: MimeType.Pdf, maxBytesPerFile: 4.5 * 1024 * 1024, maxFilesPerRequest: 5 },
+    ];
+}
+//# sourceMappingURL=claude-opus-4-7.js.map

package/dist/models/claude-sonnet-4-5.d.ts

@@ -0,0 +1,11 @@
+import { Model, ModelName } from './model.js';
+import { type SupportedFileFormat } from './types.js';
+export declare class ClaudeSonnet45 extends Model {
+    readonly name: ModelName;
+    readonly displayId: string;
+    readonly maxInputTokens: number;
+    readonly maxOutputTokens: number;
+    readonly contextWindow: number;
+    readonly supportsPromptCache: boolean;
+    readonly supportedFormats: readonly SupportedFileFormat[];
+}

package/dist/models/claude-sonnet-4-5.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { Model, ModelName } from './model.js';
+import { MimeType } from './types.js';
+export class ClaudeSonnet45 extends Model {
+    name = ModelName.CLAUDE_SONNET_4_5;
+    displayId = 'Claude Sonnet 4.5';
+    // Reference: https://help.salesforce.com/s/articleView?id=ai.generative_ai_llm_limits.htm&type=5
+    maxInputTokens = 200000;
+    maxOutputTokens = 8192;
+    contextWindow = 200000;
+    supportsPromptCache = true;
+    // Multimodal limits: 3.75 MiB / image, 4.5 MiB / PDF, 5 PDFs / request
+    // Reference: https://help.salesforce.com/s/articleView?id=ai.generative_ai_llm_multimodal_support.htm&type=5
+    supportedFormats = [
+        { name: 'png', mimeType: MimeType.Png, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'jpeg', mimeType: MimeType.Jpeg, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'pdf', mimeType: MimeType.Pdf, maxBytesPerFile: 4.5 * 1024 * 1024, maxFilesPerRequest: 5 },
+    ];
+}
+//# sourceMappingURL=claude-sonnet-4-5.js.map

package/dist/models/claude-sonnet-4-6.d.ts

@@ -0,0 +1,11 @@
+import { Model, ModelName } from './model.js';
+import { type SupportedFileFormat } from './types.js';
+export declare class ClaudeSonnet46 extends Model {
+    readonly name: ModelName;
+    readonly displayId: string;
+    readonly maxInputTokens: number;
+    readonly maxOutputTokens: number;
+    readonly contextWindow: number;
+    readonly supportsPromptCache: boolean;
+    readonly supportedFormats: readonly SupportedFileFormat[];
+}

package/dist/models/claude-sonnet-4-6.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { Model, ModelName } from './model.js';
+import { MimeType } from './types.js';
+export class ClaudeSonnet46 extends Model {
+    name = ModelName.CLAUDE_SONNET_4_6;
+    displayId = 'Claude Sonnet 4.6';
+    // See: https://help.salesforce.com/s/articleView?id=ai.generative_ai_llm_limits.htm&type=5
+    maxInputTokens = 200000;
+    maxOutputTokens = 16384;
+    contextWindow = 200000;
+    supportsPromptCache = true;
+    // Multimodal limits: 3.75 MiB / image, 4.5 MiB / PDF, 5 PDFs / request
+    supportedFormats = [
+        { name: 'png', mimeType: MimeType.Png, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'jpeg', mimeType: MimeType.Jpeg, maxBytesPerFile: 3.75 * 1024 * 1024 },
+        { name: 'pdf', mimeType: MimeType.Pdf, maxBytesPerFile: 4.5 * 1024 * 1024, maxFilesPerRequest: 5 },
+    ];
+}
+//# sourceMappingURL=claude-sonnet-4-6.js.map

package/dist/models/create-claude-model.d.ts

@@ -0,0 +1,54 @@
+import { Model } from './model.js';
+import { type SupportedFileFormat } from './types.js';
+/**
+ * Optional overrides for {@link createClaudeModel}. Any field omitted falls back to a conservative
+ * Claude-baseline default (the Sonnet 4.5 / Opus 4.5 caps) — newer flagship variants (Opus 4.6+,
+ * Sonnet 4.7+) ship with larger windows, so callers targeting a specific variant should pass the
+ * caps explicitly rather than relying on these defaults.
+ */
+export type ClaudeModelOverrides = {
+    /** Human-readable display id (e.g. `'Claude Opus 4.8'`). Defaults to the gateway id. */
+    displayId?: string;
+    /** Maximum input tokens accepted by the model. Defaults to 200_000 (Sonnet/Opus 4.5 baseline). */
+    maxInputTokens?: number;
+    /** Maximum output tokens the model can emit per response. Defaults to 64_000 (Sonnet/Opus 4.5 baseline). */
+    maxOutputTokens?: number;
+    /** Total context window. Defaults to 200_000 (Sonnet/Opus 4.5 baseline). */
+    contextWindow?: number;
+    /** Whether the gateway honors prompt caching for this model. Defaults to true. */
+    supportsPromptCache?: boolean;
+    /** Multimodal file format caps. Defaults to the Claude image+PDF caps. */
+    supportedFormats?: readonly SupportedFileFormat[];
+    /** Gateway-permitted generation parameters for this model. */
+    permittedParameters?: string[];
+    /**
+     * Extra HTTP headers to attach to chat requests for this model. Use for vendor
+     * labels (`anthropic-version`, model-tag opt-in headers) only — reserved
+     * fields like `Authorization`, `Content-Type`, `x-client-feature-id`,
+     * `x-sfdc-app-context`, and `x-sfdc-core-tenant-id` are silently shadowed by
+     * the resolver's freshly-built values. See {@link Model.customHeaders} for
+     * the full override-precedence rule.
+     */
+    customHeaders?: Record<string, string>;
+};
+/**
+ * Construct a {@link Model} instance for a Bedrock-hosted Anthropic Claude variant by
+ * gateway id without waiting for a new SDK release that adds it to {@link ModelName}.
+ *
+ * Used by consumers (notably AFV) that need to opt into a newly-published Claude model
+ * on the gateway before the SDK has released it. The returned instance carries the
+ * conservative Sonnet/Opus 4.5-baseline caps; pass `overrides` to dial caps in for the
+ * specific variant — newer flagships (Opus 4.6+, Sonnet 4.7+) ship with larger windows.
+ *
+ * @example
+ * ```ts
+ * const model = createClaudeModel('llmgateway__BedrockAnthropicClaude48Opus', {
+ *     displayId: 'Claude Opus 4.8',
+ *     maxInputTokens: 1_000_000,
+ *     contextWindow: 1_000_000,
+ *     maxOutputTokens: 128_000,
+ * });
+ * await agent.updateAgentConfig({ modelId: model });
+ * ```
+ */
+export declare function createClaudeModel(gatewayId: string, overrides?: ClaudeModelOverrides): Model;

package/dist/models/create-claude-model.js

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { Model } from './model.js';
+import { MimeType } from './types.js';
+/**
+ * Default multimodal limits shared by Bedrock-hosted Anthropic Claude variants on the
+ * Salesforce LLM Gateway: 3.75 MiB / image, 4.5 MiB / PDF, 5 PDFs / request.
+ */
+const DEFAULT_CLAUDE_SUPPORTED_FORMATS = [
+    { name: 'png', mimeType: MimeType.Png, maxBytesPerFile: 3.75 * 1024 * 1024 },
+    { name: 'jpeg', mimeType: MimeType.Jpeg, maxBytesPerFile: 3.75 * 1024 * 1024 },
+    { name: 'pdf', mimeType: MimeType.Pdf, maxBytesPerFile: 4.5 * 1024 * 1024, maxFilesPerRequest: 5 },
+];
+/**
+ * Construct a {@link Model} instance for a Bedrock-hosted Anthropic Claude variant by
+ * gateway id without waiting for a new SDK release that adds it to {@link ModelName}.
+ *
+ * Used by consumers (notably AFV) that need to opt into a newly-published Claude model
+ * on the gateway before the SDK has released it. The returned instance carries the
+ * conservative Sonnet/Opus 4.5-baseline caps; pass `overrides` to dial caps in for the
+ * specific variant — newer flagships (Opus 4.6+, Sonnet 4.7+) ship with larger windows.
+ *
+ * @example
+ * ```ts
+ * const model = createClaudeModel('llmgateway__BedrockAnthropicClaude48Opus', {
+ *     displayId: 'Claude Opus 4.8',
+ *     maxInputTokens: 1_000_000,
+ *     contextWindow: 1_000_000,
+ *     maxOutputTokens: 128_000,
+ * });
+ * await agent.updateAgentConfig({ modelId: model });
+ * ```
+ */
+export function createClaudeModel(gatewayId, overrides = {}) {
+    return new InlineClaudeModel(gatewayId, overrides);
+}
+class InlineClaudeModel extends Model {
+    name;
+    displayId;
+    maxInputTokens;
+    maxOutputTokens;
+    contextWindow;
+    supportsPromptCache;
+    supportedFormats;
+    permittedParameters;
+    customHeaders;
+    constructor(gatewayId, overrides) {
+        super();
+        this.name = gatewayId;
+        this.displayId = overrides.displayId ?? gatewayId;
+        this.maxInputTokens = overrides.maxInputTokens ?? 200_000;
+        this.maxOutputTokens = overrides.maxOutputTokens ?? 64_000;
+        this.contextWindow = overrides.contextWindow ?? 200_000;
+        this.supportsPromptCache = overrides.supportsPromptCache ?? true;
+        this.supportedFormats = overrides.supportedFormats ?? DEFAULT_CLAUDE_SUPPORTED_FORMATS;
+        this.permittedParameters = overrides.permittedParameters;
+        this.customHeaders = overrides.customHeaders;
+    }
+}
+//# sourceMappingURL=create-claude-model.js.map

package/dist/models/gpt-5-4.d.ts

@@ -0,0 +1,11 @@
+import { Model, ModelName } from './model.js';
+import { type SupportedFileFormat } from './types.js';
+export declare class GPT54 extends Model {
+    readonly name: ModelName;
+    readonly displayId: string;
+    readonly maxInputTokens: number;
+    readonly maxOutputTokens: number;
+    readonly contextWindow: number;
+    readonly supportsPromptCache: boolean;
+    readonly supportedFormats: readonly SupportedFileFormat[];
+}

package/dist/models/gpt-5-4.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { Model, ModelName } from './model.js';
+import { MimeType } from './types.js';
+export class GPT54 extends Model {
+    name = ModelName.GPT_5_4;
+    displayId = 'GPT-5.4';
+    // Source of truth: a360/file-metadata `OpenAIGPT54.yml` (maxInputToken, max_tokens.maxRangeValue).
+    maxInputTokens = 1050000;
+    maxOutputTokens = 128000;
+    contextWindow = 1050000;
+    supportsPromptCache = false;
+    supportedFormats = [
+        { name: 'png', mimeType: MimeType.Png },
+        { name: 'jpeg', mimeType: MimeType.Jpeg },
+        { name: 'pdf', mimeType: MimeType.Pdf },
+    ];
+}
+//# sourceMappingURL=gpt-5-4.js.map

package/dist/models/gpt-5-5.d.ts

@@ -0,0 +1,15 @@
+import { Model, ModelName } from './model.js';
+import { type SupportedFileFormat } from './types.js';
+/**
+ * GPT-5.5 is BETA on the gateway and gated behind the `AIModelBetaEnabled` org preference plus the
+ * `enableBetaModels` perm. Orgs without the gate active will receive a gateway error at request time.
+ */
+export declare class GPT55 extends Model {
+    readonly name: ModelName;
+    readonly displayId: string;
+    readonly maxInputTokens: number;
+    readonly maxOutputTokens: number;
+    readonly contextWindow: number;
+    readonly supportsPromptCache: boolean;
+    readonly supportedFormats: readonly SupportedFileFormat[];
+}

package/dist/models/gpt-5-5.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2026, Salesforce, Inc. All rights reserved.
+ * See LICENSE.txt for license terms.
+ */
+import { Model, ModelName } from './model.js';
+import { MimeType } from './types.js';
+/**
+ * GPT-5.5 is BETA on the gateway and gated behind the `AIModelBetaEnabled` org preference plus the
+ * `enableBetaModels` perm. Orgs without the gate active will receive a gateway error at request time.
+ */
+export class GPT55 extends Model {
+    name = ModelName.GPT_5_5;
+    displayId = 'GPT-5.5';
+    maxInputTokens = 1050000;
+    maxOutputTokens = 128000;
+    contextWindow = 1050000;
+    supportsPromptCache = false;
+    supportedFormats = [
+        { name: 'png', mimeType: MimeType.Png },
+        { name: 'jpeg', mimeType: MimeType.Jpeg },
+        { name: 'pdf', mimeType: MimeType.Pdf },
+    ];
+}
+//# sourceMappingURL=gpt-5-5.js.map