@openllmsh/sdk 0.0.0-stage → 2.10.12-alpha.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/ARCHITECTURE.md +43 -0
- package/LICENSE +202 -0
- package/README.md +142 -2
- package/assets/openllm-light.svg +18 -0
- package/assets/openllm.svg +18 -0
- package/client/chat.ts +140 -0
- package/client/devices.ts +269 -0
- package/client/http.ts +72 -0
- package/client/index.ts +129 -0
- package/client/relay-mux.ts +547 -0
- package/client/types.ts +51 -0
- package/client/vault.ts +239 -0
- package/connect/chat.ts +58 -0
- package/connect/client.ts +240 -0
- package/connect/config.ts +47 -0
- package/connect/errors.ts +121 -0
- package/connect/index.ts +23 -0
- package/connect/oauth.ts +265 -0
- package/connect/routes.ts +234 -0
- package/connect/store.ts +107 -0
- package/mcp/handle.ts +24 -0
- package/mcp/index.ts +76 -0
- package/mcp/server.ts +319 -0
- package/mcp/tools/marketplace.ts +439 -0
- package/mcp/tools/memory-client.ts +297 -0
- package/mcp/tools/memory-config.ts +32 -0
- package/mcp/tools/memory.ts +369 -0
- package/mcp/tools/model-priority.ts +88 -0
- package/mcp/tools/openllm.ts +883 -0
- package/mcp/types.ts +28 -0
- package/openapi/call.ts +90 -0
- package/openapi/index.ts +8 -0
- package/openapi/openapi.json +80213 -0
- package/openapi/operations.ts +2075 -0
- package/package.json +39 -4
- package/protocol/CONTRIBUTING.md +21 -0
- package/protocol/README.md +134 -0
- package/protocol/access.ts +186 -0
- package/protocol/agent-prompt-text.ts +32 -0
- package/protocol/agent.ts +991 -0
- package/protocol/api-key-syntax.ts +105 -0
- package/protocol/assets/openllm-light.svg +18 -0
- package/protocol/assets/openllm.svg +18 -0
- package/protocol/audio.ts +29 -0
- package/protocol/auth.ts +142 -0
- package/protocol/changelog.ts +155 -0
- package/protocol/chat.ts +458 -0
- package/protocol/client-registry.ts +356 -0
- package/protocol/config.ts +345 -0
- package/protocol/control-channel.ts +115 -0
- package/protocol/cooldown-reason.ts +78 -0
- package/protocol/cost.ts +10 -0
- package/protocol/daemon-port.ts +31 -0
- package/protocol/daemon.ts +1524 -0
- package/protocol/default-chains.ts +66 -0
- package/protocol/device-state.ts +85 -0
- package/protocol/doctor-report-local.ts +443 -0
- package/protocol/doctor-report-policy.ts +119 -0
- package/protocol/doctor-report.ts +947 -0
- package/protocol/errors.ts +14 -0
- package/protocol/execution-selection.ts +141 -0
- package/protocol/hop-grant.ts +33 -0
- package/protocol/image-edit-parse.ts +263 -0
- package/protocol/images.ts +298 -0
- package/protocol/index.ts +74 -0
- package/protocol/inference-headers.ts +3 -0
- package/protocol/keepalive.ts +69 -0
- package/protocol/local-auth.ts +300 -0
- package/protocol/local-device-control.ts +133 -0
- package/protocol/local-provider.ts +288 -0
- package/protocol/local-session.ts +118 -0
- package/protocol/marketplace.ts +187 -0
- package/protocol/media-attempt.ts +81 -0
- package/protocol/media-bytes.ts +28 -0
- package/protocol/media-default.ts +357 -0
- package/protocol/media-dimensions.ts +132 -0
- package/protocol/media-input.ts +61 -0
- package/protocol/media-model.ts +142 -0
- package/protocol/media-option-issue.ts +90 -0
- package/protocol/media-types.ts +70 -0
- package/protocol/model-match.ts +1051 -0
- package/protocol/model-settings.ts +327 -0
- package/protocol/models.ts +767 -0
- package/protocol/mux.ts +722 -0
- package/protocol/plan-surface.ts +59 -0
- package/protocol/provider-models.ts +16 -0
- package/protocol/provider-status.ts +206 -0
- package/protocol/provider-tier.ts +67 -0
- package/protocol/provider-usage.ts +263 -0
- package/protocol/providers.ts +901 -0
- package/protocol/public-usage-index.ts +354 -0
- package/protocol/realtime-generated.ts +31 -0
- package/protocol/realtime.ts +324 -0
- package/protocol/registry-pointer.ts +118 -0
- package/protocol/relay.ts +702 -0
- package/protocol/replay-session.ts +11 -0
- package/protocol/responses.ts +280 -0
- package/protocol/semver.ts +182 -0
- package/protocol/setup-mode.ts +22 -0
- package/protocol/sha256-hex.ts +98 -0
- package/protocol/stats.ts +406 -0
- package/protocol/streaming.ts +19 -0
- package/protocol/subscription-daemon-floors.ts +33 -0
- package/protocol/subscription-provider-compat.ts +104 -0
- package/protocol/subscription-provider.ts +32 -0
- package/protocol/team-grant.ts +17 -0
- package/protocol/team-shareable.ts +61 -0
- package/protocol/transcription-encoding.ts +76 -0
- package/protocol/url-locality-dns.ts +37 -0
- package/protocol/url-locality.ts +288 -0
- package/protocol/usage-snapshots.ts +9 -0
- package/protocol/vendor-cli-install.ts +29 -0
- package/protocol/video-job-plan.ts +50 -0
- package/protocol/videos.ts +227 -0
- package/tsconfig.json +14 -0
- package/tunnel/ARCHITECTURE.md +111 -0
- package/tunnel/LICENSE +33 -0
- package/tunnel/README.md +45 -0
- package/tunnel/assets/openllm-light.svg +18 -0
- package/tunnel/assets/openllm.svg +18 -0
- package/tunnel/channel-envelope.ts +139 -0
- package/tunnel/codec.ts +191 -0
- package/tunnel/device-anchor.ts +229 -0
- package/tunnel/device-control.ts +118 -0
- package/tunnel/device-grant.ts +173 -0
- package/tunnel/fleet.ts +77 -0
- package/tunnel/index.ts +22 -0
- package/tunnel/mux.ts +580 -0
- package/tunnel/peer-link.ts +390 -0
- package/tunnel/rtc-auth.ts +415 -0
- package/tunnel/rtc-duplex.ts +187 -0
- package/tunnel/rtc-ice.ts +136 -0
- package/tunnel/secure.ts +1298 -0
- package/tunnel/stream-reset-error.ts +14 -0
- package/tunnel/streams.ts +1430 -0
- package/tunnel/team-grant.ts +302 -0
- package/tunnel/wire-bytes.ts +102 -0
- package/vault/ARCHITECTURE.md +470 -0
- package/vault/LICENSE +33 -0
- package/vault/api-key.ts +190 -0
- package/vault/argon2.ts +106 -0
- package/vault/cli-auth-seal.ts +157 -0
- package/vault/cred-seal.ts +146 -0
- package/vault/credential.ts +55 -0
- package/vault/crypto.ts +210 -0
- package/vault/daemon-attest.ts +229 -0
- package/vault/derive.ts +113 -0
- package/vault/device-access.ts +87 -0
- package/vault/device-anchor.ts +185 -0
- package/vault/device-control.ts +174 -0
- package/vault/handoff.ts +396 -0
- package/vault/index.ts +21 -0
- package/vault/passkey.ts +243 -0
- package/vault/phrase.ts +65 -0
- package/vault/pin.ts +153 -0
- package/vault/public-key-seal.ts +131 -0
- package/vault/seed.ts +272 -0
- package/vault/team.ts +355 -0
- package/vault/vault-item.ts +131 -0
- package/vault/vault-migrate-digest.ts +29 -0
- package/vault/wrapped.ts +77 -0
- package/wire/ARCHITECTURE.md +90 -0
- package/wire/CONTRIBUTING.md +19 -0
- package/wire/LICENSE +33 -0
- package/wire/README.md +51 -0
- package/wire/adapters/messages/anthropic-map.ts +37 -0
- package/wire/adapters/messages/index.ts +7 -0
- package/wire/adapters/messages/reasoning-from-items.ts +38 -0
- package/wire/adapters/messages/reasoning-signature.ts +243 -0
- package/wire/adapters/messages/request.ts +574 -0
- package/wire/adapters/messages/response.ts +215 -0
- package/wire/adapters/messages/streaming.ts +1027 -0
- package/wire/adapters/messages/usage.ts +43 -0
- package/wire/adapters/responses/index.ts +3 -0
- package/wire/adapters/responses/request.ts +395 -0
- package/wire/adapters/responses/response.ts +88 -0
- package/wire/adapters/responses/streaming.ts +344 -0
- package/wire/assets/openllm-light.svg +18 -0
- package/wire/assets/openllm.svg +18 -0
- package/wire/features/account-rank.ts +166 -0
- package/wire/features/compaction/compact-request.ts +862 -0
- package/wire/features/compaction/compaction-text.ts +43 -0
- package/wire/features/context-demote.ts +47 -0
- package/wire/features/context-overflow-strategy.ts +26 -0
- package/wire/features/context-skip.ts +170 -0
- package/wire/features/conversation-affinity.ts +144 -0
- package/wire/features/max-tokens-backfill.ts +141 -0
- package/wire/features/model-caps.ts +53 -0
- package/wire/features/model-settings.ts +24 -0
- package/wire/features/output-limit-clamp.ts +64 -0
- package/wire/features/quota-gate.ts +85 -0
- package/wire/index.ts +44 -0
- package/wire/lib/attempt-outcome.ts +43 -0
- package/wire/lib/canonical/content-part.ts +38 -0
- package/wire/lib/canonical/count-tokens-capability.ts +138 -0
- package/wire/lib/canonical/encoding-select.ts +82 -0
- package/wire/lib/canonical/image-signature.ts +202 -0
- package/wire/lib/canonical/image-sse.ts +216 -0
- package/wire/lib/canonical/message.ts +43 -0
- package/wire/lib/canonical/token-estimate.ts +266 -0
- package/wire/lib/encrypted-content.ts +66 -0
- package/wire/lib/error-class.ts +154 -0
- package/wire/lib/error-envelope.ts +56 -0
- package/wire/lib/forwarded-headers.ts +180 -0
- package/wire/lib/provider-error-rules.ts +48 -0
- package/wire/lib/refusal.ts +38 -0
- package/wire/lib/responses-apply-patch.ts +104 -0
- package/wire/lib/responses-namespace.ts +53 -0
- package/wire/lib/secret-scrub.ts +101 -0
- package/wire/lib/streaming/accumulate.ts +221 -0
- package/wire/lib/streaming/finish-reason.ts +33 -0
- package/wire/lib/streaming/peek.ts +154 -0
- package/wire/lib/streaming/provider-decode.ts +259 -0
- package/wire/lib/streaming/response-stream.ts +71 -0
- package/wire/lib/streaming/sse.ts +699 -0
- package/wire/lib/streaming/strip-tool-calls.ts +95 -0
- package/wire/lib/streaming/upstream-error.ts +58 -0
- package/wire/lib/strip-subagent-isolation.ts +284 -0
- package/wire/lib/thinking-signature.ts +156 -0
- package/wire/lib/token-ruler/bpe-core.ts +426 -0
- package/wire/lib/token-ruler/index.ts +2 -0
- package/wire/lib/token-ruler/ruler.ts +79 -0
- package/wire/lib/token-ruler/vocab/claude-ranks.ts +16 -0
- package/wire/lib/token-ruler/vocab/claude.ts +22 -0
- package/wire/lib/token-ruler/vocab/o200k-ranks.ts +18 -0
- package/wire/lib/token-ruler/vocab/o200k.ts +19 -0
- package/wire/lib/tool-name-map.ts +271 -0
- package/wire/lib/tool-schema.ts +353 -0
- package/wire/lib/usage-observer.ts +125 -0
- package/wire/providers/anthropic/adaptive-thinking.ts +291 -0
- package/wire/providers/anthropic/beta-headers.ts +165 -0
- package/wire/providers/anthropic/index.ts +10 -0
- package/wire/providers/anthropic/request.ts +607 -0
- package/wire/providers/anthropic/response.ts +155 -0
- package/wire/providers/anthropic/streaming.ts +315 -0
- package/wire/providers/anthropic/web-search-domains.ts +49 -0
- package/wire/providers/chatgpt/common.ts +136 -0
- package/wire/providers/chatgpt/index.ts +9 -0
- package/wire/providers/chatgpt/request.ts +959 -0
- package/wire/providers/chatgpt/streaming.ts +1007 -0
- package/wire/providers/chatgpt/web-search.ts +63 -0
- package/wire/providers/grok/web-search.ts +87 -0
- package/wire/providers/kimi/web-search.ts +145 -0
- package/wire/providers/upstream-deny.ts +355 -0
- package/wire/providers/upstream-request.ts +619 -0
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
import type { TAnthropicUsage } from "@openllmsh/sdk/protocol";
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* Convert inclusive OpenAI-shaped prompt usage into Anthropic Messages
|
|
5
|
+
* usage. OpenAI `prompt_tokens` INCLUDES cache read/creation buckets;
|
|
6
|
+
* Anthropic `input_tokens` EXCLUDES them and reports those buckets in
|
|
7
|
+
* their own optional fields. Returning the inclusive total as
|
|
8
|
+
* `input_tokens` while also emitting cache fields double-counts.
|
|
9
|
+
*
|
|
10
|
+
* Mirror LiteLLM `adapters/transformation.py` usage mapping and the
|
|
11
|
+
* non-streaming Messages adapter: subtract once, floor at 0, omit
|
|
12
|
+
* zero/absent cache fields.
|
|
13
|
+
*/
|
|
14
|
+
export type AnthropicMessagesUsageFromInclusiveParams = {
|
|
15
|
+
promptTokens: number;
|
|
16
|
+
completionTokens: number;
|
|
17
|
+
cachedTokens?: number;
|
|
18
|
+
cacheCreationTokens?: number;
|
|
19
|
+
};
|
|
20
|
+
|
|
21
|
+
export type AnthropicMessagesUsageFromInclusiveReturnType = Pick<
|
|
22
|
+
TAnthropicUsage,
|
|
23
|
+
"input_tokens" | "output_tokens"
|
|
24
|
+
> &
|
|
25
|
+
Partial<
|
|
26
|
+
Pick<
|
|
27
|
+
TAnthropicUsage,
|
|
28
|
+
"cache_read_input_tokens" | "cache_creation_input_tokens"
|
|
29
|
+
>
|
|
30
|
+
>;
|
|
31
|
+
|
|
32
|
+
export const anthropicMessagesUsageFromInclusive = (
|
|
33
|
+
params: AnthropicMessagesUsageFromInclusiveParams,
|
|
34
|
+
): AnthropicMessagesUsageFromInclusiveReturnType => {
|
|
35
|
+
const cached = params.cachedTokens ?? 0;
|
|
36
|
+
const created = params.cacheCreationTokens ?? 0;
|
|
37
|
+
return {
|
|
38
|
+
input_tokens: Math.max(0, params.promptTokens - cached - created),
|
|
39
|
+
output_tokens: params.completionTokens,
|
|
40
|
+
...(cached > 0 ? { cache_read_input_tokens: cached } : {}),
|
|
41
|
+
...(created > 0 ? { cache_creation_input_tokens: created } : {}),
|
|
42
|
+
};
|
|
43
|
+
};
|
|
@@ -0,0 +1,395 @@
|
|
|
1
|
+
import type {
|
|
2
|
+
TChatCompletionRequest,
|
|
3
|
+
TChatMessage,
|
|
4
|
+
TResponsesInputItem,
|
|
5
|
+
TResponsesRequest,
|
|
6
|
+
TToolCall,
|
|
7
|
+
} from "@openllmsh/sdk/protocol";
|
|
8
|
+
import type { TCanonicalContentPart } from "../../lib/canonical/content-part";
|
|
9
|
+
import {
|
|
10
|
+
APPLY_PATCH_FUNCTION_NAME,
|
|
11
|
+
applyPatchFunctionTool,
|
|
12
|
+
isHostedApplyPatchTool,
|
|
13
|
+
} from "../../lib/responses-apply-patch";
|
|
14
|
+
import {
|
|
15
|
+
canonicalToolNameOf,
|
|
16
|
+
joinNamespacedToolName,
|
|
17
|
+
} from "../../lib/responses-namespace";
|
|
18
|
+
|
|
19
|
+
/**
|
|
20
|
+
* Inbound adapter: OpenAI **Responses API** request → canonical
|
|
21
|
+
* ChatCompletion request. The inverse of `toChatGptRequest`
|
|
22
|
+
* (`@openllmsh/sdk/wire/providers/chatgpt/request.ts`), so a Codex client (which
|
|
23
|
+
* speaks only the Responses API) can drive the gateway's normal pipeline.
|
|
24
|
+
*
|
|
25
|
+
* - `instructions` → a leading `system` message.
|
|
26
|
+
* - `input` (string) → a single `user` message.
|
|
27
|
+
* - `input` item `message` → user/assistant/system message (parts →
|
|
28
|
+
* canonical text/image content).
|
|
29
|
+
* - `input` item `function_call` → an `assistant` message with one
|
|
30
|
+
* `tool_calls` entry.
|
|
31
|
+
* - `input` item `function_call_output` → a `tool` message.
|
|
32
|
+
* - `input` item `reasoning` → carried onto the NEXT assistant message's
|
|
33
|
+
* `reasoning_items` so it round-trips.
|
|
34
|
+
* - `input` item `additional_tools` → opaque Responses-tool passthrough only
|
|
35
|
+
* (never a canonical message).
|
|
36
|
+
* - flat `tools`/`tool_choice` → canonical wrapped shapes.
|
|
37
|
+
* - `reasoning.effort` → `reasoning_effort`; `max_output_tokens` → `max_tokens`.
|
|
38
|
+
*/
|
|
39
|
+
|
|
40
|
+
// Message items are the only input items carrying `content` with a `role`
|
|
41
|
+
// (their `type` is optional), so select them by `role` rather than `type`.
|
|
42
|
+
type TResponsesContentPart = Extract<
|
|
43
|
+
TResponsesInputItem,
|
|
44
|
+
{ role: "user" | "assistant" | "system" | "developer"; content: unknown }
|
|
45
|
+
>["content"];
|
|
46
|
+
|
|
47
|
+
/** Responses content (string | parts) → canonical content (string | parts). */
|
|
48
|
+
const toCanonicalContent = (
|
|
49
|
+
content: TResponsesContentPart,
|
|
50
|
+
): string | TCanonicalContentPart[] => {
|
|
51
|
+
if (typeof content === "string") return content;
|
|
52
|
+
const parts: TCanonicalContentPart[] = [];
|
|
53
|
+
for (const p of content) {
|
|
54
|
+
if (p.type === "input_text" || p.type === "output_text") {
|
|
55
|
+
parts.push({ type: "text", text: p.text });
|
|
56
|
+
} else if (p.type === "input_image") {
|
|
57
|
+
parts.push({
|
|
58
|
+
type: "image_url",
|
|
59
|
+
image_url: {
|
|
60
|
+
url: p.image_url,
|
|
61
|
+
...(p.detail !== undefined ? { detail: p.detail } : {}),
|
|
62
|
+
},
|
|
63
|
+
});
|
|
64
|
+
} else if (p.type === "input_file") {
|
|
65
|
+
parts.push({
|
|
66
|
+
type: "file",
|
|
67
|
+
file: {
|
|
68
|
+
...(p.file_data !== undefined ? { file_data: p.file_data } : {}),
|
|
69
|
+
...(p.file_id != null ? { file_id: p.file_id } : {}),
|
|
70
|
+
...(p.filename !== undefined ? { filename: p.filename } : {}),
|
|
71
|
+
},
|
|
72
|
+
});
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
return parts;
|
|
76
|
+
};
|
|
77
|
+
|
|
78
|
+
/** Flatten Responses content to plain text (for `tool` message bodies). */
|
|
79
|
+
const contentToText = (content: TResponsesContentPart): string => {
|
|
80
|
+
if (typeof content === "string") return content;
|
|
81
|
+
return content
|
|
82
|
+
.map((p) =>
|
|
83
|
+
p.type === "input_text" || p.type === "output_text" ? p.text : "",
|
|
84
|
+
)
|
|
85
|
+
.join("");
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
/**
|
|
89
|
+
* Canonical tools — `function` tools, plus every function member of a Codex
|
|
90
|
+
* `namespace` tool (MCP servers, sub-agents) flattened to
|
|
91
|
+
* `<namespace>--<name>` (`lib/responses-namespace.ts`; the response encoders
|
|
92
|
+
* split it back). Namespaces arrive top-level or, on Codex ≥0.147, inside a
|
|
93
|
+
* leading `additional_tools` input item — both are flattened. Codex's non-function built-ins
|
|
94
|
+
* (`custom` apply_patch, `web_search`, `image_generation`, `tool_search`) have
|
|
95
|
+
* no canonical representation, so they're dropped here; they survive for the
|
|
96
|
+
* chatgpt upstream via the verbatim `responses_tools` passthrough instead (see
|
|
97
|
+
* `fromResponsesRequest`). For a cross-wire upstream (anthropic / openai-chat)
|
|
98
|
+
* the non-function tools can't be honoured anyway, so dropping them is correct.
|
|
99
|
+
*/
|
|
100
|
+
type TResponsesToolEntry = NonNullable<TResponsesRequest["tools"]>[number];
|
|
101
|
+
|
|
102
|
+
const isFunctionTool = (t: unknown): t is TResponsesToolEntry =>
|
|
103
|
+
typeof t === "object" &&
|
|
104
|
+
t !== null &&
|
|
105
|
+
(t as { type?: unknown }).type === "function" &&
|
|
106
|
+
typeof (t as { name?: unknown }).name === "string";
|
|
107
|
+
|
|
108
|
+
/** Function members of a namespace tool, renamed to the canonical join. */
|
|
109
|
+
const flattenNamespace = (t: TResponsesToolEntry): TResponsesToolEntry[] => {
|
|
110
|
+
if (t.type !== "namespace" || typeof t.name !== "string") return [];
|
|
111
|
+
const members = (t as { tools?: unknown }).tools;
|
|
112
|
+
if (!Array.isArray(members)) return [];
|
|
113
|
+
const ns = t.name;
|
|
114
|
+
return members
|
|
115
|
+
.filter(isFunctionTool)
|
|
116
|
+
.map((m) => ({ ...m, name: joinNamespacedToolName(ns, m.name as string) }));
|
|
117
|
+
};
|
|
118
|
+
|
|
119
|
+
const mapTools = (
|
|
120
|
+
tools: ReadonlyArray<TResponsesToolEntry>,
|
|
121
|
+
): TChatCompletionRequest["tools"] => {
|
|
122
|
+
const fns = tools.flatMap((t) =>
|
|
123
|
+
t.type === "namespace" ? flattenNamespace(t) : isFunctionTool(t) ? [t] : [],
|
|
124
|
+
);
|
|
125
|
+
if (fns.length === 0) return undefined;
|
|
126
|
+
return fns.map((t) => ({
|
|
127
|
+
type: "function" as const,
|
|
128
|
+
function: {
|
|
129
|
+
name: t.name as string,
|
|
130
|
+
...(t.description != null ? { description: t.description } : {}),
|
|
131
|
+
...(t.parameters !== undefined ? { parameters: t.parameters } : {}),
|
|
132
|
+
...(t.strict != null ? { strict: t.strict } : {}),
|
|
133
|
+
},
|
|
134
|
+
}));
|
|
135
|
+
};
|
|
136
|
+
|
|
137
|
+
const mapToolChoice = (
|
|
138
|
+
choice: TResponsesRequest["tool_choice"],
|
|
139
|
+
): TChatCompletionRequest["tool_choice"] => {
|
|
140
|
+
if (choice == null || typeof choice === "string") return choice ?? undefined;
|
|
141
|
+
if (choice.type === "allowed_tools") return choice.mode;
|
|
142
|
+
if (choice.type === "apply_patch") {
|
|
143
|
+
return { type: "function", function: { name: APPLY_PATCH_FUNCTION_NAME } };
|
|
144
|
+
}
|
|
145
|
+
return { type: "function", function: { name: choice.name } };
|
|
146
|
+
};
|
|
147
|
+
|
|
148
|
+
type TAllowedToolRef = { readonly type: string; readonly name?: string };
|
|
149
|
+
|
|
150
|
+
const isAllowedTool = (
|
|
151
|
+
tool: TResponsesToolEntry,
|
|
152
|
+
allowed: ReadonlyArray<TAllowedToolRef>,
|
|
153
|
+
): boolean =>
|
|
154
|
+
allowed.some(
|
|
155
|
+
(ref) =>
|
|
156
|
+
ref.type === tool.type &&
|
|
157
|
+
(ref.name === undefined || ref.name === tool.name),
|
|
158
|
+
);
|
|
159
|
+
|
|
160
|
+
/**
|
|
161
|
+
* A namespace tool narrowed by `allowed_tools`: kept whole when the namespace
|
|
162
|
+
* itself is allowed, otherwise cut down to its allowed function members (by
|
|
163
|
+
* bare or canonical joined name), and dropped when none remain.
|
|
164
|
+
*/
|
|
165
|
+
const narrowNamespace = (
|
|
166
|
+
tool: TResponsesToolEntry,
|
|
167
|
+
allowed: ReadonlyArray<TAllowedToolRef>,
|
|
168
|
+
): TResponsesToolEntry[] => {
|
|
169
|
+
if (isAllowedTool(tool, allowed)) return [tool];
|
|
170
|
+
const members = (tool as { tools?: unknown }).tools;
|
|
171
|
+
if (typeof tool.name !== "string" || !Array.isArray(members)) return [];
|
|
172
|
+
const ns = tool.name;
|
|
173
|
+
const kept = members.filter(
|
|
174
|
+
(m) =>
|
|
175
|
+
isFunctionTool(m) &&
|
|
176
|
+
allowed.some(
|
|
177
|
+
(ref) =>
|
|
178
|
+
ref.type === "function" &&
|
|
179
|
+
(ref.name === m.name ||
|
|
180
|
+
ref.name === joinNamespacedToolName(ns, m.name as string)),
|
|
181
|
+
),
|
|
182
|
+
);
|
|
183
|
+
return kept.length === 0 ? [] : [{ ...tool, tools: kept }];
|
|
184
|
+
};
|
|
185
|
+
|
|
186
|
+
/**
|
|
187
|
+
* Normalize the declared tools before anything reads them:
|
|
188
|
+
* - `tool_choice: allowed_tools` narrows the declared list to the allowed
|
|
189
|
+
* subset (no upstream but OpenAI's own API takes the choice itself; the
|
|
190
|
+
* narrowed list gives the same turn semantics at the cost of the tool
|
|
191
|
+
* prefix's prompt-cache hit).
|
|
192
|
+
* - the hosted `apply_patch` tool becomes its function stand-in, which every
|
|
193
|
+
* upstream can call (`lib/responses-apply-patch.ts`).
|
|
194
|
+
*/
|
|
195
|
+
/** Tools left callable by `tool_choice: allowed_tools` (all of them otherwise). */
|
|
196
|
+
const narrowToAllowed = (
|
|
197
|
+
tools: ReadonlyArray<TResponsesToolEntry>,
|
|
198
|
+
choice: TResponsesRequest["tool_choice"],
|
|
199
|
+
): TResponsesToolEntry[] =>
|
|
200
|
+
choice != null &&
|
|
201
|
+
typeof choice !== "string" &&
|
|
202
|
+
choice.type === "allowed_tools"
|
|
203
|
+
? tools.flatMap((t) =>
|
|
204
|
+
t.type === "namespace"
|
|
205
|
+
? narrowNamespace(t, choice.tools)
|
|
206
|
+
: isAllowedTool(t, choice.tools)
|
|
207
|
+
? [t]
|
|
208
|
+
: [],
|
|
209
|
+
)
|
|
210
|
+
: [...tools];
|
|
211
|
+
|
|
212
|
+
const normalizeTools = (
|
|
213
|
+
tools: ReadonlyArray<TResponsesToolEntry>,
|
|
214
|
+
choice: TResponsesRequest["tool_choice"],
|
|
215
|
+
): TResponsesToolEntry[] => {
|
|
216
|
+
const narrowed = narrowToAllowed(tools, choice);
|
|
217
|
+
return narrowed.map((t) =>
|
|
218
|
+
isHostedApplyPatchTool(t) ? applyPatchFunctionTool : t,
|
|
219
|
+
);
|
|
220
|
+
};
|
|
221
|
+
|
|
222
|
+
/** A replayed `apply_patch_call` output's status + text as a tool result. */
|
|
223
|
+
const applyPatchOutputText = (
|
|
224
|
+
status: string | undefined,
|
|
225
|
+
output: string | null | undefined,
|
|
226
|
+
): string =>
|
|
227
|
+
output != null && output.length > 0
|
|
228
|
+
? `${status ?? "completed"}: ${output}`
|
|
229
|
+
: (status ?? "completed");
|
|
230
|
+
|
|
231
|
+
/** Codex sends `minimal`; the canonical enum has it, so pass effort through. */
|
|
232
|
+
const mapEffort = (
|
|
233
|
+
reasoning: TResponsesRequest["reasoning"],
|
|
234
|
+
): TChatCompletionRequest["reasoning_effort"] => {
|
|
235
|
+
const e = reasoning?.effort;
|
|
236
|
+
return e === undefined || e === null ? undefined : e;
|
|
237
|
+
};
|
|
238
|
+
|
|
239
|
+
export const fromResponsesRequest = (
|
|
240
|
+
req: TResponsesRequest,
|
|
241
|
+
): TChatCompletionRequest => {
|
|
242
|
+
const messages: TChatMessage[] = [];
|
|
243
|
+
// Codex v0.147 moves its namespace-scoped harness tools into leading
|
|
244
|
+
// `additional_tools` input items. Keep top-level Responses tools and those
|
|
245
|
+
// leading input items as DISTINCT opaque carriers: their placement changes
|
|
246
|
+
// the ChatGPT/Codex upstream contract. Flat top-level functions and the
|
|
247
|
+
// members of namespace tools (from either place) map to canonical `tools`.
|
|
248
|
+
const responsesTools =
|
|
249
|
+
req.tools == null ? [] : normalizeTools(req.tools, req.tool_choice);
|
|
250
|
+
const responsesAdditionalTools: unknown[] = [];
|
|
251
|
+
|
|
252
|
+
const instr = req.instructions;
|
|
253
|
+
if (typeof instr === "string" && instr.trim().length > 0) {
|
|
254
|
+
messages.push({ role: "system", content: instr });
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
// Buffer reasoning items until the next assistant-role output, which they
|
|
258
|
+
// precede in the Responses `input` ordering (mirrors `toChatGptRequest`).
|
|
259
|
+
let pendingReasoning: unknown[] = [];
|
|
260
|
+
const takeReasoning = (): { reasoning_items?: ReadonlyArray<unknown> } => {
|
|
261
|
+
if (pendingReasoning.length === 0) return {};
|
|
262
|
+
const items = pendingReasoning;
|
|
263
|
+
pendingReasoning = [];
|
|
264
|
+
return { reasoning_items: items };
|
|
265
|
+
};
|
|
266
|
+
|
|
267
|
+
if (typeof req.input === "string") {
|
|
268
|
+
messages.push({ role: "user", content: req.input });
|
|
269
|
+
} else {
|
|
270
|
+
for (const item of req.input) {
|
|
271
|
+
if (item.type === "reasoning") {
|
|
272
|
+
pendingReasoning.push(item);
|
|
273
|
+
} else if (item.type === "additional_tools") {
|
|
274
|
+
// Preserve the entire input item rather than hoisting its nested tools.
|
|
275
|
+
// The Codex upstream distinguishes harness declarations in input from
|
|
276
|
+
// model-facing tools at the top level. `allowed_tools` narrows it too,
|
|
277
|
+
// so an excluded harness tool doesn't stay callable through it.
|
|
278
|
+
const tools = narrowToAllowed(item.tools, req.tool_choice);
|
|
279
|
+
if (tools.length > 0) {
|
|
280
|
+
responsesAdditionalTools.push(
|
|
281
|
+
tools.length === item.tools.length &&
|
|
282
|
+
tools.every((t, i) => t === item.tools[i])
|
|
283
|
+
? item
|
|
284
|
+
: { ...item, tools },
|
|
285
|
+
);
|
|
286
|
+
}
|
|
287
|
+
} else if (item.type === "function_call") {
|
|
288
|
+
const toolCall: TToolCall = {
|
|
289
|
+
id: item.call_id,
|
|
290
|
+
type: "function",
|
|
291
|
+
function: {
|
|
292
|
+
name: canonicalToolNameOf(item.name, item.namespace),
|
|
293
|
+
arguments: item.arguments,
|
|
294
|
+
},
|
|
295
|
+
};
|
|
296
|
+
messages.push({
|
|
297
|
+
role: "assistant",
|
|
298
|
+
content: null,
|
|
299
|
+
tool_calls: [toolCall],
|
|
300
|
+
...takeReasoning(),
|
|
301
|
+
});
|
|
302
|
+
} else if (item.type === "function_call_output") {
|
|
303
|
+
messages.push({
|
|
304
|
+
role: "tool",
|
|
305
|
+
tool_call_id: item.call_id,
|
|
306
|
+
content: contentToText(item.output),
|
|
307
|
+
});
|
|
308
|
+
} else if (item.type === "apply_patch_call") {
|
|
309
|
+
messages.push({
|
|
310
|
+
role: "assistant",
|
|
311
|
+
content: null,
|
|
312
|
+
tool_calls: [
|
|
313
|
+
{
|
|
314
|
+
id: item.call_id,
|
|
315
|
+
type: "function",
|
|
316
|
+
function: {
|
|
317
|
+
name: APPLY_PATCH_FUNCTION_NAME,
|
|
318
|
+
arguments: JSON.stringify(item.operation ?? {}),
|
|
319
|
+
},
|
|
320
|
+
},
|
|
321
|
+
],
|
|
322
|
+
...takeReasoning(),
|
|
323
|
+
});
|
|
324
|
+
} else if (item.type === "apply_patch_call_output") {
|
|
325
|
+
messages.push({
|
|
326
|
+
role: "tool",
|
|
327
|
+
tool_call_id: item.call_id,
|
|
328
|
+
content: applyPatchOutputText(item.status, item.output),
|
|
329
|
+
});
|
|
330
|
+
} else {
|
|
331
|
+
// message item
|
|
332
|
+
const role = item.role === "developer" ? "system" : item.role;
|
|
333
|
+
const content = toCanonicalContent(item.content);
|
|
334
|
+
if (role === "assistant") {
|
|
335
|
+
messages.push({ role: "assistant", content, ...takeReasoning() });
|
|
336
|
+
} else {
|
|
337
|
+
messages.push({ role, content });
|
|
338
|
+
}
|
|
339
|
+
}
|
|
340
|
+
}
|
|
341
|
+
// Trailing reasoning with no assistant output to attach to.
|
|
342
|
+
if (pendingReasoning.length > 0) {
|
|
343
|
+
messages.push({ role: "assistant", content: null, ...takeReasoning() });
|
|
344
|
+
}
|
|
345
|
+
}
|
|
346
|
+
|
|
347
|
+
const tools = mapTools([
|
|
348
|
+
...responsesTools,
|
|
349
|
+
...responsesAdditionalTools.flatMap((item) => {
|
|
350
|
+
const nested = (item as { tools?: unknown }).tools;
|
|
351
|
+
// Only namespaces: plain harness functions here stay ChatGPT-only.
|
|
352
|
+
return Array.isArray(nested)
|
|
353
|
+
? (nested as TResponsesToolEntry[]).filter(
|
|
354
|
+
(t) => t.type === "namespace",
|
|
355
|
+
)
|
|
356
|
+
: [];
|
|
357
|
+
}),
|
|
358
|
+
]);
|
|
359
|
+
const toolChoice = mapToolChoice(req.tool_choice);
|
|
360
|
+
const effort = mapEffort(req.reasoning);
|
|
361
|
+
|
|
362
|
+
return {
|
|
363
|
+
model: req.model,
|
|
364
|
+
messages,
|
|
365
|
+
stream: req.stream === true,
|
|
366
|
+
...(tools !== undefined ? { tools } : {}),
|
|
367
|
+
// Carry the ORIGINAL Responses tools verbatim (function + non-function) so
|
|
368
|
+
// a chatgpt upstream re-emits Codex's apply_patch / web_search / … intact.
|
|
369
|
+
// Stripped before every openai-family upstream. See the schema field doc.
|
|
370
|
+
...(responsesTools.length > 0 ? { responses_tools: responsesTools } : {}),
|
|
371
|
+
...(responsesAdditionalTools.length > 0
|
|
372
|
+
? { responses_additional_tools: responsesAdditionalTools }
|
|
373
|
+
: {}),
|
|
374
|
+
...(req.client_metadata !== undefined
|
|
375
|
+
? { responses_client_metadata: req.client_metadata }
|
|
376
|
+
: {}),
|
|
377
|
+
...(toolChoice !== undefined ? { tool_choice: toolChoice } : {}),
|
|
378
|
+
...(effort !== undefined ? { reasoning_effort: effort } : {}),
|
|
379
|
+
...(req.max_output_tokens != null
|
|
380
|
+
? { max_tokens: req.max_output_tokens }
|
|
381
|
+
: {}),
|
|
382
|
+
...(req.temperature != null ? { temperature: req.temperature } : {}),
|
|
383
|
+
...(req.top_p != null ? { top_p: req.top_p } : {}),
|
|
384
|
+
...(req.service_tier != null ? { service_tier: req.service_tier } : {}),
|
|
385
|
+
...(req.parallel_tool_calls != null
|
|
386
|
+
? { parallel_tool_calls: req.parallel_tool_calls }
|
|
387
|
+
: {}),
|
|
388
|
+
// Preserve Codex's per-conversation prompt-cache key so the re-encoded
|
|
389
|
+
// upstream keeps routing to the same cache (rather than synthesizing a new
|
|
390
|
+
// one). Absent → `toChatGptRequest` derives a stable key from the prefix.
|
|
391
|
+
...(req.prompt_cache_key != null
|
|
392
|
+
? { prompt_cache_key: req.prompt_cache_key }
|
|
393
|
+
: {}),
|
|
394
|
+
};
|
|
395
|
+
};
|
|
@@ -0,0 +1,88 @@
|
|
|
1
|
+
import type {
|
|
2
|
+
TChatCompletionResponse,
|
|
3
|
+
TResponsesOutputItem,
|
|
4
|
+
TResponsesResponse,
|
|
5
|
+
} from "@openllmsh/sdk/protocol";
|
|
6
|
+
import { extractMessageText } from "../../lib/canonical/message";
|
|
7
|
+
import {
|
|
8
|
+
APPLY_PATCH_FUNCTION_NAME,
|
|
9
|
+
toApplyPatchCallItem,
|
|
10
|
+
} from "../../lib/responses-apply-patch";
|
|
11
|
+
import { responsesCallIdentity } from "../../lib/responses-namespace";
|
|
12
|
+
import {
|
|
13
|
+
reasoningItemsFromUnknown,
|
|
14
|
+
reasoningItemToResponsesInput,
|
|
15
|
+
} from "../messages/reasoning-signature";
|
|
16
|
+
|
|
17
|
+
/**
|
|
18
|
+
* Outbound adapter (non-streaming): canonical ChatCompletion response →
|
|
19
|
+
* OpenAI **Responses API** response. The inverse direction of the inbound
|
|
20
|
+
* request adapter; lets a Codex client read a `/v1/responses` reply.
|
|
21
|
+
*
|
|
22
|
+
* Output-item order mirrors the Responses API: reasoning item(s) first, then
|
|
23
|
+
* the assistant message (if it has text), then any function calls. A `length`
|
|
24
|
+
* finish maps to `status: "incomplete"`, everything else to `"completed"`.
|
|
25
|
+
*/
|
|
26
|
+
export const toResponsesResponse = (
|
|
27
|
+
resp: TChatCompletionResponse,
|
|
28
|
+
): TResponsesResponse => {
|
|
29
|
+
const choice = resp.choices[0];
|
|
30
|
+
const msg = choice?.message;
|
|
31
|
+
const output: TResponsesOutputItem[] = [];
|
|
32
|
+
|
|
33
|
+
if (msg?.reasoning_items != null) {
|
|
34
|
+
for (const r of reasoningItemsFromUnknown(msg.reasoning_items)) {
|
|
35
|
+
const item = reasoningItemToResponsesInput(r);
|
|
36
|
+
output.push({
|
|
37
|
+
...item,
|
|
38
|
+
id: item.id ?? (r.id.length > 0 ? r.id : `rs_${crypto.randomUUID()}`),
|
|
39
|
+
});
|
|
40
|
+
}
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
const text = msg != null ? extractMessageText(msg.content) : "";
|
|
44
|
+
if (text.length > 0) {
|
|
45
|
+
output.push({
|
|
46
|
+
type: "message",
|
|
47
|
+
id: `msg_${resp.id}`,
|
|
48
|
+
role: "assistant",
|
|
49
|
+
status: "completed",
|
|
50
|
+
content: [{ type: "output_text", text }],
|
|
51
|
+
});
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
if (msg?.tool_calls != null) {
|
|
55
|
+
for (const tc of msg.tool_calls) {
|
|
56
|
+
const applyPatch =
|
|
57
|
+
tc.function.name === APPLY_PATCH_FUNCTION_NAME
|
|
58
|
+
? toApplyPatchCallItem(`fc_${tc.id}`, tc.id, tc.function.arguments)
|
|
59
|
+
: undefined;
|
|
60
|
+
if (applyPatch !== undefined) {
|
|
61
|
+
output.push(applyPatch);
|
|
62
|
+
continue;
|
|
63
|
+
}
|
|
64
|
+
output.push({
|
|
65
|
+
type: "function_call",
|
|
66
|
+
id: `fc_${tc.id}`,
|
|
67
|
+
call_id: tc.id,
|
|
68
|
+
...responsesCallIdentity(tc.function.name),
|
|
69
|
+
arguments: tc.function.arguments,
|
|
70
|
+
status: "completed",
|
|
71
|
+
});
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
|
|
75
|
+
return {
|
|
76
|
+
id: resp.id,
|
|
77
|
+
object: "response",
|
|
78
|
+
created_at: resp.created,
|
|
79
|
+
status: choice?.finish_reason === "length" ? "incomplete" : "completed",
|
|
80
|
+
model: resp.model,
|
|
81
|
+
output,
|
|
82
|
+
usage: {
|
|
83
|
+
input_tokens: resp.usage.prompt_tokens,
|
|
84
|
+
output_tokens: resp.usage.completion_tokens,
|
|
85
|
+
total_tokens: resp.usage.total_tokens,
|
|
86
|
+
},
|
|
87
|
+
};
|
|
88
|
+
};
|