@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,202 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Bounded image-signature + dimension inspector. Filename/extension is not
|
|
3
|
+
* evidence: live Cursor output was JPEG bytes saved as `.png`. Callers pass
|
|
4
|
+
* the whole buffer (or a prefix large enough for headers); parsers never
|
|
5
|
+
* scan past a small header budget except JPEG SOF, which walks markers with
|
|
6
|
+
* a hard byte cap.
|
|
7
|
+
*/
|
|
8
|
+
|
|
9
|
+
export const IMAGE_INSPECT_MAX_BYTES = 20 * 1024 * 1024;
|
|
10
|
+
export const IMAGE_DIMENSION_MAX = 8_192;
|
|
11
|
+
|
|
12
|
+
export type TInspectedImageMime =
|
|
13
|
+
| "image/png"
|
|
14
|
+
| "image/jpeg"
|
|
15
|
+
| "image/webp"
|
|
16
|
+
| "image/gif";
|
|
17
|
+
|
|
18
|
+
export type TInspectedImage = {
|
|
19
|
+
readonly mime: TInspectedImageMime;
|
|
20
|
+
readonly width: number;
|
|
21
|
+
readonly height: number;
|
|
22
|
+
};
|
|
23
|
+
|
|
24
|
+
const PNG_SIG = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a] as const;
|
|
25
|
+
const JPEG_SOI0 = 0xff;
|
|
26
|
+
const JPEG_SOI1 = 0xd8;
|
|
27
|
+
const GIF87 = [0x47, 0x49, 0x46, 0x38, 0x37, 0x61] as const;
|
|
28
|
+
const GIF89 = [0x47, 0x49, 0x46, 0x38, 0x39, 0x61] as const;
|
|
29
|
+
const RIFF = [0x52, 0x49, 0x46, 0x46] as const;
|
|
30
|
+
const WEBP = [0x57, 0x45, 0x42, 0x50] as const;
|
|
31
|
+
|
|
32
|
+
const u16be = (bytes: Uint8Array, offset: number): number =>
|
|
33
|
+
((bytes[offset] ?? 0) << 8) | (bytes[offset + 1] ?? 0);
|
|
34
|
+
|
|
35
|
+
const u16le = (bytes: Uint8Array, offset: number): number =>
|
|
36
|
+
(bytes[offset] ?? 0) | ((bytes[offset + 1] ?? 0) << 8);
|
|
37
|
+
|
|
38
|
+
const u24le = (bytes: Uint8Array, offset: number): number =>
|
|
39
|
+
(bytes[offset] ?? 0) |
|
|
40
|
+
((bytes[offset + 1] ?? 0) << 8) |
|
|
41
|
+
((bytes[offset + 2] ?? 0) << 16);
|
|
42
|
+
|
|
43
|
+
const u32be = (bytes: Uint8Array, offset: number): number =>
|
|
44
|
+
((bytes[offset] ?? 0) * 0x1000000 +
|
|
45
|
+
((bytes[offset + 1] ?? 0) << 16) +
|
|
46
|
+
((bytes[offset + 2] ?? 0) << 8) +
|
|
47
|
+
(bytes[offset + 3] ?? 0)) >>>
|
|
48
|
+
0;
|
|
49
|
+
|
|
50
|
+
const startsWith = (
|
|
51
|
+
bytes: Uint8Array,
|
|
52
|
+
sig: ReadonlyArray<number>,
|
|
53
|
+
offset = 0,
|
|
54
|
+
): boolean => {
|
|
55
|
+
if (bytes.length < offset + sig.length) return false;
|
|
56
|
+
for (let i = 0; i < sig.length; i++) {
|
|
57
|
+
if (bytes[offset + i] !== sig[i]) return false;
|
|
58
|
+
}
|
|
59
|
+
return true;
|
|
60
|
+
};
|
|
61
|
+
|
|
62
|
+
const validDims = (width: number, height: number): boolean =>
|
|
63
|
+
Number.isInteger(width) &&
|
|
64
|
+
Number.isInteger(height) &&
|
|
65
|
+
width > 0 &&
|
|
66
|
+
height > 0 &&
|
|
67
|
+
width <= IMAGE_DIMENSION_MAX &&
|
|
68
|
+
height <= IMAGE_DIMENSION_MAX;
|
|
69
|
+
|
|
70
|
+
const inspectPng = (bytes: Uint8Array): TInspectedImage | null => {
|
|
71
|
+
if (!startsWith(bytes, PNG_SIG)) return null;
|
|
72
|
+
// IHDR: 8 sig + 4 len + 4 type + 4 width + 4 height
|
|
73
|
+
if (bytes.length < 24) return null;
|
|
74
|
+
if (
|
|
75
|
+
bytes[12] !== 0x49 ||
|
|
76
|
+
bytes[13] !== 0x48 ||
|
|
77
|
+
bytes[14] !== 0x44 ||
|
|
78
|
+
bytes[15] !== 0x52
|
|
79
|
+
) {
|
|
80
|
+
return null;
|
|
81
|
+
}
|
|
82
|
+
const width = u32be(bytes, 16);
|
|
83
|
+
const height = u32be(bytes, 20);
|
|
84
|
+
if (!validDims(width, height)) return null;
|
|
85
|
+
return { mime: "image/png", width, height };
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
/** Walk JPEG markers until SOF0/1/2; ignore SOS payload. Cap the walk. */
|
|
89
|
+
const inspectJpeg = (bytes: Uint8Array): TInspectedImage | null => {
|
|
90
|
+
if (bytes.length < 4) return null;
|
|
91
|
+
if (bytes[0] !== JPEG_SOI0 || bytes[1] !== JPEG_SOI1) return null;
|
|
92
|
+
let i = 2;
|
|
93
|
+
const cap = Math.min(bytes.length, 64 * 1024);
|
|
94
|
+
while (i + 9 < cap) {
|
|
95
|
+
if (bytes[i] !== 0xff) {
|
|
96
|
+
i += 1;
|
|
97
|
+
continue;
|
|
98
|
+
}
|
|
99
|
+
let marker = bytes[i + 1] ?? 0;
|
|
100
|
+
while (marker === 0xff && i + 2 < cap) {
|
|
101
|
+
i += 1;
|
|
102
|
+
marker = bytes[i + 1] ?? 0;
|
|
103
|
+
}
|
|
104
|
+
if (marker === 0xd8 || marker === 0xd9 || marker === 0x01) {
|
|
105
|
+
i += 2;
|
|
106
|
+
continue;
|
|
107
|
+
}
|
|
108
|
+
// RST / TEM have no length
|
|
109
|
+
if (marker >= 0xd0 && marker <= 0xd7) {
|
|
110
|
+
i += 2;
|
|
111
|
+
continue;
|
|
112
|
+
}
|
|
113
|
+
if (i + 4 >= cap) return null;
|
|
114
|
+
const len = u16be(bytes, i + 2);
|
|
115
|
+
if (len < 2) return null;
|
|
116
|
+
// SOF0 / SOF1 / SOF2
|
|
117
|
+
if (marker === 0xc0 || marker === 0xc1 || marker === 0xc2) {
|
|
118
|
+
if (i + 9 >= cap) return null;
|
|
119
|
+
const height = u16be(bytes, i + 5);
|
|
120
|
+
const width = u16be(bytes, i + 7);
|
|
121
|
+
if (!validDims(width, height)) return null;
|
|
122
|
+
return { mime: "image/jpeg", width, height };
|
|
123
|
+
}
|
|
124
|
+
if (marker === 0xda) return null; // SOS without SOF
|
|
125
|
+
i += 2 + len;
|
|
126
|
+
}
|
|
127
|
+
return null;
|
|
128
|
+
};
|
|
129
|
+
|
|
130
|
+
const inspectGif = (bytes: Uint8Array): TInspectedImage | null => {
|
|
131
|
+
if (!startsWith(bytes, GIF87) && !startsWith(bytes, GIF89)) return null;
|
|
132
|
+
if (bytes.length < 10) return null;
|
|
133
|
+
const width = u16le(bytes, 6);
|
|
134
|
+
const height = u16le(bytes, 8);
|
|
135
|
+
if (!validDims(width, height)) return null;
|
|
136
|
+
return { mime: "image/gif", width, height };
|
|
137
|
+
};
|
|
138
|
+
|
|
139
|
+
const inspectWebp = (bytes: Uint8Array): TInspectedImage | null => {
|
|
140
|
+
if (!startsWith(bytes, RIFF) || !startsWith(bytes, WEBP, 8)) return null;
|
|
141
|
+
if (bytes.length < 30) return null;
|
|
142
|
+
const fourcc =
|
|
143
|
+
String.fromCharCode(bytes[12] ?? 0) +
|
|
144
|
+
String.fromCharCode(bytes[13] ?? 0) +
|
|
145
|
+
String.fromCharCode(bytes[14] ?? 0) +
|
|
146
|
+
String.fromCharCode(bytes[15] ?? 0);
|
|
147
|
+
if (fourcc === "VP8X") {
|
|
148
|
+
if (bytes.length < 30) return null;
|
|
149
|
+
const width = u24le(bytes, 24) + 1;
|
|
150
|
+
const height = u24le(bytes, 27) + 1;
|
|
151
|
+
if (!validDims(width, height)) return null;
|
|
152
|
+
return { mime: "image/webp", width, height };
|
|
153
|
+
}
|
|
154
|
+
if (fourcc === "VP8 ") {
|
|
155
|
+
// lossy: bytes 16-19 are the "VP8 " chunk size, 20-22 the 3-byte VP8
|
|
156
|
+
// frame tag, THEN the 0x9d 0x01 0x2a start code at 23-25, followed by
|
|
157
|
+
// 16-bit width (26-27) / height (28-29). Verified against real
|
|
158
|
+
// cwebp-encoded output — see `tests/transport/image-signature-webp.test.ts`
|
|
159
|
+
// — a previous off-by-3 read the start code at 20-22 and dims at
|
|
160
|
+
// 23/25, which never matched a real VP8 lossy stream.
|
|
161
|
+
if (bytes.length < 30) return null;
|
|
162
|
+
if (bytes[23] !== 0x9d || bytes[24] !== 0x01 || bytes[25] !== 0x2a) {
|
|
163
|
+
return null;
|
|
164
|
+
}
|
|
165
|
+
const width = u16le(bytes, 26) & 0x3fff;
|
|
166
|
+
const height = u16le(bytes, 28) & 0x3fff;
|
|
167
|
+
if (!validDims(width, height)) return null;
|
|
168
|
+
return { mime: "image/webp", width, height };
|
|
169
|
+
}
|
|
170
|
+
if (fourcc === "VP8L") {
|
|
171
|
+
if (bytes.length < 25) return null;
|
|
172
|
+
if (bytes[20] !== 0x2f) return null;
|
|
173
|
+
const bits =
|
|
174
|
+
(bytes[21] ?? 0) |
|
|
175
|
+
((bytes[22] ?? 0) << 8) |
|
|
176
|
+
((bytes[23] ?? 0) << 16) |
|
|
177
|
+
((bytes[24] ?? 0) << 24);
|
|
178
|
+
const width = (bits & 0x3fff) + 1;
|
|
179
|
+
const height = ((bits >> 14) & 0x3fff) + 1;
|
|
180
|
+
if (!validDims(width, height)) return null;
|
|
181
|
+
return { mime: "image/webp", width, height };
|
|
182
|
+
}
|
|
183
|
+
return null;
|
|
184
|
+
};
|
|
185
|
+
|
|
186
|
+
/**
|
|
187
|
+
* Sniff magic + dimensions. Returns null for truncated, oversized, unknown,
|
|
188
|
+
* or out-of-range dimensions. Does not throw.
|
|
189
|
+
*/
|
|
190
|
+
export const inspectImageBytes = (
|
|
191
|
+
bytes: Uint8Array,
|
|
192
|
+
): TInspectedImage | null => {
|
|
193
|
+
if (bytes.byteLength === 0 || bytes.byteLength > IMAGE_INSPECT_MAX_BYTES) {
|
|
194
|
+
return null;
|
|
195
|
+
}
|
|
196
|
+
return (
|
|
197
|
+
inspectPng(bytes) ??
|
|
198
|
+
inspectJpeg(bytes) ??
|
|
199
|
+
inspectGif(bytes) ??
|
|
200
|
+
inspectWebp(bytes)
|
|
201
|
+
);
|
|
202
|
+
};
|
|
@@ -0,0 +1,216 @@
|
|
|
1
|
+
import type {
|
|
2
|
+
TImageStreamCompletedEvent,
|
|
3
|
+
TImageStreamEvent,
|
|
4
|
+
TImageStreamPartialEvent,
|
|
5
|
+
} from "@openllmsh/sdk/protocol";
|
|
6
|
+
import { sseEventStream } from "../streaming/sse";
|
|
7
|
+
|
|
8
|
+
/**
|
|
9
|
+
* Canonical `/v1/images/generations` SSE.
|
|
10
|
+
*
|
|
11
|
+
* THE RULE THIS FILE EXISTS TO ENFORCE: the gateway always serves an honest
|
|
12
|
+
* stream, and never a simulated one. Concretely:
|
|
13
|
+
*
|
|
14
|
+
* - A provider that genuinely emits progressive frames has them forwarded as
|
|
15
|
+
* they arrive, in order, unbuffered.
|
|
16
|
+
* - A provider that returns one finished image (Gemini, Grok, any
|
|
17
|
+
* OpenAI-compatible endpoint that ignores `stream`) yields exactly ONE
|
|
18
|
+
* `image_generation.completed` event and ZERO partials. We never chop a
|
|
19
|
+
* buffered final image into fake `partial_image` frames, and we never
|
|
20
|
+
* invent a `partial_image_index`.
|
|
21
|
+
* - Keepalive is an SSE COMMENT line, never a zero-progress event, so it
|
|
22
|
+
* cannot be mistaken for progress by any client.
|
|
23
|
+
*
|
|
24
|
+
* Framing follows the pinned spec: NAMED events (`event: image_generation.…`)
|
|
25
|
+
* and NO `[DONE]` sentinel — `[DONE]` is chat framing and does not appear in
|
|
26
|
+
* the images spec. The `completed` event is the terminator.
|
|
27
|
+
*/
|
|
28
|
+
|
|
29
|
+
const encoder = new TextEncoder();
|
|
30
|
+
|
|
31
|
+
/** One named SSE frame. The spec frames image events by name, not by `data` alone. */
|
|
32
|
+
export const encodeImageSseEvent = (event: TImageStreamEvent): Uint8Array =>
|
|
33
|
+
encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
|
|
34
|
+
|
|
35
|
+
/**
|
|
36
|
+
* A terminal error frame. Used when generation SUCCEEDED but the gateway
|
|
37
|
+
* could not durably store the image: the caller must not be told the
|
|
38
|
+
* operation completed when the media-library URL it implies does not exist.
|
|
39
|
+
*/
|
|
40
|
+
export const encodeImageSseError = (message: string): Uint8Array =>
|
|
41
|
+
encoder.encode(
|
|
42
|
+
`event: error\ndata: ${JSON.stringify({ error: { message, type: "persistence_error" } })}\n\n`,
|
|
43
|
+
);
|
|
44
|
+
|
|
45
|
+
/**
|
|
46
|
+
* An inert SSE COMMENT. A comment can never be parsed as an event by any
|
|
47
|
+
* client, which is exactly why it is the only honest vehicle for something
|
|
48
|
+
* that is not a result: a keepalive, or a note explaining what the stream
|
|
49
|
+
* will NOT contain. Never use an event frame for either — that is how a
|
|
50
|
+
* zero-progress frame ends up masquerading as progress.
|
|
51
|
+
*/
|
|
52
|
+
export const encodeImageSseComment = (text: string): Uint8Array =>
|
|
53
|
+
encoder.encode(`: ${text}\n\n`);
|
|
54
|
+
|
|
55
|
+
/** Liveness only, for a stream opened before the work completes. */
|
|
56
|
+
export const encodeImageSseKeepalive = (): Uint8Array =>
|
|
57
|
+
encodeImageSseComment("keepalive");
|
|
58
|
+
|
|
59
|
+
/**
|
|
60
|
+
* Told to the caller when they asked for partial frames the resolved model is
|
|
61
|
+
* KNOWN not to emit. Without it the request silently yields one completion
|
|
62
|
+
* and the caller is left to guess whether partials were lost or never
|
|
63
|
+
* existed. Emitted only on a positive catalog fact
|
|
64
|
+
* (`nativeProgressiveImages === false`) — never on absent/unknown caps, which
|
|
65
|
+
* must stay permissive.
|
|
66
|
+
*/
|
|
67
|
+
export const encodeImageSsePartialsUnavailable = (): Uint8Array =>
|
|
68
|
+
encodeImageSseComment(
|
|
69
|
+
"partial_images requested, but this model does not emit progressive image frames; a single completion event will follow",
|
|
70
|
+
);
|
|
71
|
+
|
|
72
|
+
const isPartial = (v: unknown): v is TImageStreamPartialEvent =>
|
|
73
|
+
typeof v === "object" &&
|
|
74
|
+
v !== null &&
|
|
75
|
+
(v as { type?: unknown }).type === "image_generation.partial_image";
|
|
76
|
+
|
|
77
|
+
const isCompleted = (v: unknown): v is TImageStreamCompletedEvent =>
|
|
78
|
+
typeof v === "object" &&
|
|
79
|
+
v !== null &&
|
|
80
|
+
(v as { type?: unknown }).type === "image_generation.completed";
|
|
81
|
+
|
|
82
|
+
export type TUpstreamImageEvents = {
|
|
83
|
+
/** Genuine progressive frames, in arrival order. Empty for a final-only provider. */
|
|
84
|
+
readonly partials: ReadonlyArray<TImageStreamPartialEvent>;
|
|
85
|
+
readonly completed: TImageStreamCompletedEvent | null;
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
/**
|
|
89
|
+
* Read an upstream SSE image stream into its events.
|
|
90
|
+
*
|
|
91
|
+
* Callers that need true progressive forwarding use {@link readImageSse}
|
|
92
|
+
* instead; this collector exists for the non-progressive case and for tests.
|
|
93
|
+
*/
|
|
94
|
+
export const collectImageSse = async (
|
|
95
|
+
upstream: Response,
|
|
96
|
+
): Promise<TUpstreamImageEvents> => {
|
|
97
|
+
const partials: TImageStreamPartialEvent[] = [];
|
|
98
|
+
let completed: TImageStreamCompletedEvent | null = null;
|
|
99
|
+
for await (const event of readImageSse(upstream)) {
|
|
100
|
+
if (isPartial(event)) partials.push(event);
|
|
101
|
+
else if (isCompleted(event)) completed = event;
|
|
102
|
+
}
|
|
103
|
+
return { partials, completed };
|
|
104
|
+
};
|
|
105
|
+
|
|
106
|
+
/**
|
|
107
|
+
* Yield upstream image events as they arrive. Unknown event types are skipped
|
|
108
|
+
* rather than failing the stream — a provider adding an event we don't model
|
|
109
|
+
* must not break a generation that otherwise succeeded.
|
|
110
|
+
*/
|
|
111
|
+
export async function* readImageSse(
|
|
112
|
+
upstream: Response,
|
|
113
|
+
): AsyncGenerator<TImageStreamEvent> {
|
|
114
|
+
const body = upstream.body;
|
|
115
|
+
if (body === null) return;
|
|
116
|
+
const reader = sseEventStream(body).getReader();
|
|
117
|
+
try {
|
|
118
|
+
for (;;) {
|
|
119
|
+
const { value, done } = await reader.read();
|
|
120
|
+
if (done) return;
|
|
121
|
+
if (value === undefined || value.kind !== "data") continue;
|
|
122
|
+
let parsed: unknown;
|
|
123
|
+
try {
|
|
124
|
+
parsed = JSON.parse(value.data);
|
|
125
|
+
} catch {
|
|
126
|
+
continue;
|
|
127
|
+
}
|
|
128
|
+
if (isPartial(parsed) || isCompleted(parsed)) yield parsed;
|
|
129
|
+
}
|
|
130
|
+
} finally {
|
|
131
|
+
reader.releaseLock();
|
|
132
|
+
}
|
|
133
|
+
}
|
|
134
|
+
|
|
135
|
+
/**
|
|
136
|
+
* Build a `completed` event for a provider that returned a finished image
|
|
137
|
+
* rather than a stream. Every field carries a REAL value from that response —
|
|
138
|
+
* notably `usage`, which is preserved rather than zeroed. Nothing here
|
|
139
|
+
* fabricates progress: the absence of partials IS the honest signal that the
|
|
140
|
+
* upstream was not progressive.
|
|
141
|
+
*/
|
|
142
|
+
export const completedEventFromFinalImage = (input: {
|
|
143
|
+
readonly b64_json: string;
|
|
144
|
+
readonly createdAt: number;
|
|
145
|
+
readonly size?: string;
|
|
146
|
+
readonly quality?: string;
|
|
147
|
+
readonly background?: string;
|
|
148
|
+
readonly outputFormat?: string;
|
|
149
|
+
readonly usage?: TImageStreamCompletedEvent["usage"];
|
|
150
|
+
}): TImageStreamCompletedEvent => ({
|
|
151
|
+
type: "image_generation.completed",
|
|
152
|
+
b64_json: input.b64_json,
|
|
153
|
+
created_at: input.createdAt,
|
|
154
|
+
...(input.size !== undefined ? { size: input.size } : {}),
|
|
155
|
+
...(input.quality !== undefined ? { quality: input.quality } : {}),
|
|
156
|
+
...(input.background !== undefined ? { background: input.background } : {}),
|
|
157
|
+
...(input.outputFormat !== undefined
|
|
158
|
+
? { output_format: input.outputFormat }
|
|
159
|
+
: {}),
|
|
160
|
+
...(input.usage !== undefined ? { usage: input.usage } : {}),
|
|
161
|
+
});
|
|
162
|
+
|
|
163
|
+
/**
|
|
164
|
+
* Collapse an image SSE stream into the JSON body a non-streaming consumer
|
|
165
|
+
* expects.
|
|
166
|
+
*
|
|
167
|
+
* Intended for a caller WITHOUT an SSE reader. The previous approach silently
|
|
168
|
+
* rewrote such a request to `stream: false`, which overrode a choice the
|
|
169
|
+
* caller had made and meant an agent asking to stream got something else with
|
|
170
|
+
* no indication. Aggregating instead honours the request end to end: the HTTP
|
|
171
|
+
* surface still streams and progressive frames still reach anyone reading
|
|
172
|
+
* them, while the tool consumer receives a final result it can render.
|
|
173
|
+
*
|
|
174
|
+
* Partials are DISCARDED rather than concatenated: they are successive
|
|
175
|
+
* previews of one image, not fragments of it. Returns null when the stream
|
|
176
|
+
* carried no completion.
|
|
177
|
+
*
|
|
178
|
+
* ⚠ SINGLE-IMAGE ONLY, AND CURRENTLY UNUSED. It keeps the LAST completion, so
|
|
179
|
+
* an `n > 1` response — which emits one completion PER image — collapses to
|
|
180
|
+
* the final one and the rest are lost. No production caller reaches it today:
|
|
181
|
+
* the MCP tool deliberately implements its own `aggregateImageSseText` in
|
|
182
|
+
* `packages/cli/src/mcp/openllm/tools.ts`, which keeps EVERY completion.
|
|
183
|
+
* Before wiring this into any consumer that can request `n > 1`, make it
|
|
184
|
+
* return all completions rather than adopting it as-is.
|
|
185
|
+
*/
|
|
186
|
+
export const aggregateImageSse = async (
|
|
187
|
+
upstream: Response,
|
|
188
|
+
): Promise<TImageStreamCompletedEvent | null> => {
|
|
189
|
+
let last: TImageStreamCompletedEvent | null = null;
|
|
190
|
+
for await (const event of readImageSse(upstream)) {
|
|
191
|
+
if (isCompleted(event)) last = event;
|
|
192
|
+
}
|
|
193
|
+
return last;
|
|
194
|
+
};
|
|
195
|
+
|
|
196
|
+
/** The aggregated completion as an `ImagesResponse`-shaped JSON body. */
|
|
197
|
+
export const imageSseToJsonBody = (
|
|
198
|
+
completed: TImageStreamCompletedEvent,
|
|
199
|
+
): Record<string, unknown> => ({
|
|
200
|
+
created: completed.created_at,
|
|
201
|
+
data: [
|
|
202
|
+
{
|
|
203
|
+
b64_json: completed.b64_json,
|
|
204
|
+
...(completed.url !== undefined ? { url: completed.url } : {}),
|
|
205
|
+
},
|
|
206
|
+
],
|
|
207
|
+
...(completed.usage !== undefined ? { usage: completed.usage } : {}),
|
|
208
|
+
...(completed.size !== undefined ? { size: completed.size } : {}),
|
|
209
|
+
...(completed.quality !== undefined ? { quality: completed.quality } : {}),
|
|
210
|
+
...(completed.background !== undefined
|
|
211
|
+
? { background: completed.background }
|
|
212
|
+
: {}),
|
|
213
|
+
...(completed.output_format !== undefined
|
|
214
|
+
? { output_format: completed.output_format }
|
|
215
|
+
: {}),
|
|
216
|
+
});
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Provider-agnostic helpers over the canonical OpenAI ChatCompletion
|
|
3
|
+
* message shape. These are NOT provider quirks — they are the same
|
|
4
|
+
* operation every provider needs on the way out, so they live once
|
|
5
|
+
* here rather than re-inlined per provider.
|
|
6
|
+
*
|
|
7
|
+
* Note: the inbound `adapters/messages` response path deliberately
|
|
8
|
+
* keeps its own text flattener (it joins with "" over a *response*
|
|
9
|
+
* content type, not "\n" over a request message) — that divergence is
|
|
10
|
+
* intentional and must not be folded in here.
|
|
11
|
+
*/
|
|
12
|
+
import type { TChatMessage } from "@openllmsh/sdk/protocol";
|
|
13
|
+
|
|
14
|
+
/**
|
|
15
|
+
* Flatten a canonical message `content` (string | content-part[]) to
|
|
16
|
+
* plain text: keep only `text` parts, joined by newlines. `null` /
|
|
17
|
+
* `undefined` → `""`.
|
|
18
|
+
*/
|
|
19
|
+
export const extractMessageText = (
|
|
20
|
+
content: TChatMessage["content"] | null | undefined,
|
|
21
|
+
): string => {
|
|
22
|
+
if (content == null) return "";
|
|
23
|
+
if (typeof content === "string") return content;
|
|
24
|
+
return content
|
|
25
|
+
.filter((part) => part.type === "text")
|
|
26
|
+
.map((part) => (part as { type: "text"; text: string }).text)
|
|
27
|
+
.join("\n");
|
|
28
|
+
};
|
|
29
|
+
|
|
30
|
+
/**
|
|
31
|
+
* Deserialize an OpenAI tool-call `arguments` string. Empty → `{}`;
|
|
32
|
+
* valid JSON → parsed value; unparseable → the raw string verbatim
|
|
33
|
+
* (Anthropic `tool_use.input` and the Messages adapter both accept a
|
|
34
|
+
* raw string as a last resort).
|
|
35
|
+
*/
|
|
36
|
+
export const parseToolArguments = (raw: string): unknown => {
|
|
37
|
+
if (raw.length === 0) return {};
|
|
38
|
+
try {
|
|
39
|
+
return JSON.parse(raw);
|
|
40
|
+
} catch {
|
|
41
|
+
return raw;
|
|
42
|
+
}
|
|
43
|
+
};
|