@openllmsh/sdk 2.10.19-alpha.1 → 2.10.19-alpha.3

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.
@@ -26779,27 +26779,6 @@
26779
26779
  "id": {
26780
26780
  "type": "string"
26781
26781
  },
26782
- "kind": {
26783
- "type": "string",
26784
- "enum": [
26785
- "routing"
26786
- ]
26787
- },
26788
- "capabilities": {
26789
- "type": "object",
26790
- "properties": {
26791
- "device_sessions": {
26792
- "type": "boolean",
26793
- "enum": [
26794
- false
26795
- ]
26796
- }
26797
- },
26798
- "required": [
26799
- "device_sessions"
26800
- ],
26801
- "additionalProperties": false
26802
- },
26803
26782
  "state": {
26804
26783
  "type": "string",
26805
26784
  "enum": [
@@ -26863,6 +26842,31 @@
26863
26842
  }
26864
26843
  ]
26865
26844
  },
26845
+ "reset_epoch": {
26846
+ "anyOf": [
26847
+ {
26848
+ "type": "number"
26849
+ },
26850
+ {
26851
+ "type": "string",
26852
+ "enum": [
26853
+ "Infinity",
26854
+ "-Infinity",
26855
+ "NaN"
26856
+ ]
26857
+ }
26858
+ ]
26859
+ },
26860
+ "subject_id": {
26861
+ "anyOf": [
26862
+ {
26863
+ "type": "string"
26864
+ },
26865
+ {
26866
+ "type": "null"
26867
+ }
26868
+ ]
26869
+ },
26866
26870
  "unlock_sent": {
26867
26871
  "type": "boolean"
26868
26872
  },
@@ -26914,14 +26918,14 @@
26914
26918
  },
26915
26919
  "required": [
26916
26920
  "id",
26917
- "kind",
26918
- "capabilities",
26919
26921
  "state",
26920
26922
  "generation",
26921
26923
  "public_ipv4",
26922
26924
  "failure_code",
26923
26925
  "vault_key_id",
26924
26926
  "key_id",
26927
+ "reset_epoch",
26928
+ "subject_id",
26925
26929
  "unlock_sent",
26926
26930
  "boot",
26927
26931
  "created_at",
@@ -26933,6 +26937,24 @@
26933
26937
  "type": "null"
26934
26938
  }
26935
26939
  ]
26940
+ },
26941
+ "notice": {
26942
+ "anyOf": [
26943
+ {
26944
+ "type": "string",
26945
+ "enum": [
26946
+ "machine_gone",
26947
+ "machine_moved",
26948
+ "no_machine_available"
26949
+ ]
26950
+ },
26951
+ {
26952
+ "type": "null"
26953
+ },
26954
+ {
26955
+ "type": "null"
26956
+ }
26957
+ ]
26936
26958
  }
26937
26959
  },
26938
26960
  "required": [
@@ -27352,27 +27374,6 @@
27352
27374
  "id": {
27353
27375
  "type": "string"
27354
27376
  },
27355
- "kind": {
27356
- "type": "string",
27357
- "enum": [
27358
- "routing"
27359
- ]
27360
- },
27361
- "capabilities": {
27362
- "type": "object",
27363
- "properties": {
27364
- "device_sessions": {
27365
- "type": "boolean",
27366
- "enum": [
27367
- false
27368
- ]
27369
- }
27370
- },
27371
- "required": [
27372
- "device_sessions"
27373
- ],
27374
- "additionalProperties": false
27375
- },
27376
27377
  "state": {
27377
27378
  "type": "string",
27378
27379
  "enum": [
@@ -27436,6 +27437,31 @@
27436
27437
  }
27437
27438
  ]
27438
27439
  },
27440
+ "reset_epoch": {
27441
+ "anyOf": [
27442
+ {
27443
+ "type": "number"
27444
+ },
27445
+ {
27446
+ "type": "string",
27447
+ "enum": [
27448
+ "Infinity",
27449
+ "-Infinity",
27450
+ "NaN"
27451
+ ]
27452
+ }
27453
+ ]
27454
+ },
27455
+ "subject_id": {
27456
+ "anyOf": [
27457
+ {
27458
+ "type": "string"
27459
+ },
27460
+ {
27461
+ "type": "null"
27462
+ }
27463
+ ]
27464
+ },
27439
27465
  "unlock_sent": {
27440
27466
  "type": "boolean"
27441
27467
  },
@@ -27487,14 +27513,14 @@
27487
27513
  },
27488
27514
  "required": [
27489
27515
  "id",
27490
- "kind",
27491
- "capabilities",
27492
27516
  "state",
27493
27517
  "generation",
27494
27518
  "public_ipv4",
27495
27519
  "failure_code",
27496
27520
  "vault_key_id",
27497
27521
  "key_id",
27522
+ "reset_epoch",
27523
+ "subject_id",
27498
27524
  "unlock_sent",
27499
27525
  "boot",
27500
27526
  "created_at",
@@ -27506,6 +27532,24 @@
27506
27532
  "type": "null"
27507
27533
  }
27508
27534
  ]
27535
+ },
27536
+ "notice": {
27537
+ "anyOf": [
27538
+ {
27539
+ "type": "string",
27540
+ "enum": [
27541
+ "machine_gone",
27542
+ "machine_moved",
27543
+ "no_machine_available"
27544
+ ]
27545
+ },
27546
+ {
27547
+ "type": "null"
27548
+ },
27549
+ {
27550
+ "type": "null"
27551
+ }
27552
+ ]
27509
27553
  }
27510
27554
  },
27511
27555
  "required": [
@@ -27531,27 +27575,6 @@
27531
27575
  "id": {
27532
27576
  "type": "string"
27533
27577
  },
27534
- "kind": {
27535
- "type": "string",
27536
- "enum": [
27537
- "routing"
27538
- ]
27539
- },
27540
- "capabilities": {
27541
- "type": "object",
27542
- "properties": {
27543
- "device_sessions": {
27544
- "type": "boolean",
27545
- "enum": [
27546
- false
27547
- ]
27548
- }
27549
- },
27550
- "required": [
27551
- "device_sessions"
27552
- ],
27553
- "additionalProperties": false
27554
- },
27555
27578
  "state": {
27556
27579
  "type": "string",
27557
27580
  "enum": [
@@ -27615,6 +27638,31 @@
27615
27638
  }
27616
27639
  ]
27617
27640
  },
27641
+ "reset_epoch": {
27642
+ "anyOf": [
27643
+ {
27644
+ "type": "number"
27645
+ },
27646
+ {
27647
+ "type": "string",
27648
+ "enum": [
27649
+ "Infinity",
27650
+ "-Infinity",
27651
+ "NaN"
27652
+ ]
27653
+ }
27654
+ ]
27655
+ },
27656
+ "subject_id": {
27657
+ "anyOf": [
27658
+ {
27659
+ "type": "string"
27660
+ },
27661
+ {
27662
+ "type": "null"
27663
+ }
27664
+ ]
27665
+ },
27618
27666
  "unlock_sent": {
27619
27667
  "type": "boolean"
27620
27668
  },
@@ -27666,14 +27714,14 @@
27666
27714
  },
27667
27715
  "required": [
27668
27716
  "id",
27669
- "kind",
27670
- "capabilities",
27671
27717
  "state",
27672
27718
  "generation",
27673
27719
  "public_ipv4",
27674
27720
  "failure_code",
27675
27721
  "vault_key_id",
27676
27722
  "key_id",
27723
+ "reset_epoch",
27724
+ "subject_id",
27677
27725
  "unlock_sent",
27678
27726
  "boot",
27679
27727
  "created_at",
@@ -27685,6 +27733,24 @@
27685
27733
  "type": "null"
27686
27734
  }
27687
27735
  ]
27736
+ },
27737
+ "notice": {
27738
+ "anyOf": [
27739
+ {
27740
+ "type": "string",
27741
+ "enum": [
27742
+ "machine_gone",
27743
+ "machine_moved",
27744
+ "no_machine_available"
27745
+ ]
27746
+ },
27747
+ {
27748
+ "type": "null"
27749
+ },
27750
+ {
27751
+ "type": "null"
27752
+ }
27753
+ ]
27688
27754
  }
27689
27755
  },
27690
27756
  "required": [
@@ -28115,27 +28181,6 @@
28115
28181
  "id": {
28116
28182
  "type": "string"
28117
28183
  },
28118
- "kind": {
28119
- "type": "string",
28120
- "enum": [
28121
- "routing"
28122
- ]
28123
- },
28124
- "capabilities": {
28125
- "type": "object",
28126
- "properties": {
28127
- "device_sessions": {
28128
- "type": "boolean",
28129
- "enum": [
28130
- false
28131
- ]
28132
- }
28133
- },
28134
- "required": [
28135
- "device_sessions"
28136
- ],
28137
- "additionalProperties": false
28138
- },
28139
28184
  "state": {
28140
28185
  "type": "string",
28141
28186
  "enum": [
@@ -28199,6 +28244,31 @@
28199
28244
  }
28200
28245
  ]
28201
28246
  },
28247
+ "reset_epoch": {
28248
+ "anyOf": [
28249
+ {
28250
+ "type": "number"
28251
+ },
28252
+ {
28253
+ "type": "string",
28254
+ "enum": [
28255
+ "Infinity",
28256
+ "-Infinity",
28257
+ "NaN"
28258
+ ]
28259
+ }
28260
+ ]
28261
+ },
28262
+ "subject_id": {
28263
+ "anyOf": [
28264
+ {
28265
+ "type": "string"
28266
+ },
28267
+ {
28268
+ "type": "null"
28269
+ }
28270
+ ]
28271
+ },
28202
28272
  "unlock_sent": {
28203
28273
  "type": "boolean"
28204
28274
  },
@@ -28250,14 +28320,14 @@
28250
28320
  },
28251
28321
  "required": [
28252
28322
  "id",
28253
- "kind",
28254
- "capabilities",
28255
28323
  "state",
28256
28324
  "generation",
28257
28325
  "public_ipv4",
28258
28326
  "failure_code",
28259
28327
  "vault_key_id",
28260
28328
  "key_id",
28329
+ "reset_epoch",
28330
+ "subject_id",
28261
28331
  "unlock_sent",
28262
28332
  "boot",
28263
28333
  "created_at",
@@ -28269,6 +28339,24 @@
28269
28339
  "type": "null"
28270
28340
  }
28271
28341
  ]
28342
+ },
28343
+ "notice": {
28344
+ "anyOf": [
28345
+ {
28346
+ "type": "string",
28347
+ "enum": [
28348
+ "machine_gone",
28349
+ "machine_moved",
28350
+ "no_machine_available"
28351
+ ]
28352
+ },
28353
+ {
28354
+ "type": "null"
28355
+ },
28356
+ {
28357
+ "type": "null"
28358
+ }
28359
+ ]
28272
28360
  }
28273
28361
  },
28274
28362
  "required": [
@@ -28699,27 +28787,6 @@
28699
28787
  "id": {
28700
28788
  "type": "string"
28701
28789
  },
28702
- "kind": {
28703
- "type": "string",
28704
- "enum": [
28705
- "routing"
28706
- ]
28707
- },
28708
- "capabilities": {
28709
- "type": "object",
28710
- "properties": {
28711
- "device_sessions": {
28712
- "type": "boolean",
28713
- "enum": [
28714
- false
28715
- ]
28716
- }
28717
- },
28718
- "required": [
28719
- "device_sessions"
28720
- ],
28721
- "additionalProperties": false
28722
- },
28723
28790
  "state": {
28724
28791
  "type": "string",
28725
28792
  "enum": [
@@ -28783,6 +28850,31 @@
28783
28850
  }
28784
28851
  ]
28785
28852
  },
28853
+ "reset_epoch": {
28854
+ "anyOf": [
28855
+ {
28856
+ "type": "number"
28857
+ },
28858
+ {
28859
+ "type": "string",
28860
+ "enum": [
28861
+ "Infinity",
28862
+ "-Infinity",
28863
+ "NaN"
28864
+ ]
28865
+ }
28866
+ ]
28867
+ },
28868
+ "subject_id": {
28869
+ "anyOf": [
28870
+ {
28871
+ "type": "string"
28872
+ },
28873
+ {
28874
+ "type": "null"
28875
+ }
28876
+ ]
28877
+ },
28786
28878
  "unlock_sent": {
28787
28879
  "type": "boolean"
28788
28880
  },
@@ -28834,14 +28926,14 @@
28834
28926
  },
28835
28927
  "required": [
28836
28928
  "id",
28837
- "kind",
28838
- "capabilities",
28839
28929
  "state",
28840
28930
  "generation",
28841
28931
  "public_ipv4",
28842
28932
  "failure_code",
28843
28933
  "vault_key_id",
28844
28934
  "key_id",
28935
+ "reset_epoch",
28936
+ "subject_id",
28845
28937
  "unlock_sent",
28846
28938
  "boot",
28847
28939
  "created_at",
@@ -28853,6 +28945,24 @@
28853
28945
  "type": "null"
28854
28946
  }
28855
28947
  ]
28948
+ },
28949
+ "notice": {
28950
+ "anyOf": [
28951
+ {
28952
+ "type": "string",
28953
+ "enum": [
28954
+ "machine_gone",
28955
+ "machine_moved",
28956
+ "no_machine_available"
28957
+ ]
28958
+ },
28959
+ {
28960
+ "type": "null"
28961
+ },
28962
+ {
28963
+ "type": "null"
28964
+ }
28965
+ ]
28856
28966
  }
28857
28967
  },
28858
28968
  "required": [
@@ -29283,27 +29393,6 @@
29283
29393
  "id": {
29284
29394
  "type": "string"
29285
29395
  },
29286
- "kind": {
29287
- "type": "string",
29288
- "enum": [
29289
- "routing"
29290
- ]
29291
- },
29292
- "capabilities": {
29293
- "type": "object",
29294
- "properties": {
29295
- "device_sessions": {
29296
- "type": "boolean",
29297
- "enum": [
29298
- false
29299
- ]
29300
- }
29301
- },
29302
- "required": [
29303
- "device_sessions"
29304
- ],
29305
- "additionalProperties": false
29306
- },
29307
29396
  "state": {
29308
29397
  "type": "string",
29309
29398
  "enum": [
@@ -29367,6 +29456,31 @@
29367
29456
  }
29368
29457
  ]
29369
29458
  },
29459
+ "reset_epoch": {
29460
+ "anyOf": [
29461
+ {
29462
+ "type": "number"
29463
+ },
29464
+ {
29465
+ "type": "string",
29466
+ "enum": [
29467
+ "Infinity",
29468
+ "-Infinity",
29469
+ "NaN"
29470
+ ]
29471
+ }
29472
+ ]
29473
+ },
29474
+ "subject_id": {
29475
+ "anyOf": [
29476
+ {
29477
+ "type": "string"
29478
+ },
29479
+ {
29480
+ "type": "null"
29481
+ }
29482
+ ]
29483
+ },
29370
29484
  "unlock_sent": {
29371
29485
  "type": "boolean"
29372
29486
  },
@@ -29418,14 +29532,14 @@
29418
29532
  },
29419
29533
  "required": [
29420
29534
  "id",
29421
- "kind",
29422
- "capabilities",
29423
29535
  "state",
29424
29536
  "generation",
29425
29537
  "public_ipv4",
29426
29538
  "failure_code",
29427
29539
  "vault_key_id",
29428
29540
  "key_id",
29541
+ "reset_epoch",
29542
+ "subject_id",
29429
29543
  "unlock_sent",
29430
29544
  "boot",
29431
29545
  "created_at",
@@ -29437,6 +29551,24 @@
29437
29551
  "type": "null"
29438
29552
  }
29439
29553
  ]
29554
+ },
29555
+ "notice": {
29556
+ "anyOf": [
29557
+ {
29558
+ "type": "string",
29559
+ "enum": [
29560
+ "machine_gone",
29561
+ "machine_moved",
29562
+ "no_machine_available"
29563
+ ]
29564
+ },
29565
+ {
29566
+ "type": "null"
29567
+ },
29568
+ {
29569
+ "type": "null"
29570
+ }
29571
+ ]
29440
29572
  }
29441
29573
  },
29442
29574
  "required": [
@@ -55,6 +55,13 @@ export type TMintedApiKey = {
55
55
  * 6. shows `sk-llm-{id}.{secret_b64url}` once.
56
56
  */
57
57
  export declare const mintApiKey: (dek: Uint8Array, vaultVersion: number) => Promise<TMintedApiKey>;
58
+ /**
59
+ * {@link mintApiKey} with a caller-chosen `(id, secret)` — for a key that must
60
+ * be re-derivable (the Routebox's, from the seed). The DEK wrap and the sealed
61
+ * copy still use random nonces, so the row differs per call but the `sk-llm`
62
+ * string is the same. Never zeroes `apiKeySecret`.
63
+ */
64
+ export declare const mintApiKeyFrom: (dek: Uint8Array, vaultVersion: number, apiKeyId: string, apiKeySecret: Uint8Array) => Promise<TMintedApiKey>;
58
65
  /** The secret columns of an `api_keys` row re-wrapped under a new DEK. */
59
66
  export type TRewrappedApiKey = {
60
67
  readonly dek_for_key: string;
@@ -71,9 +71,17 @@ const newApiKeyId = () => toB64Url(randomBytes(OPENLLM_API_KEY_ID_BYTES));
71
71
  * vault_version }` to `/api/keys`,
72
72
  * 6. shows `sk-llm-{id}.{secret_b64url}` once.
73
73
  */
74
- export const mintApiKey = async (dek, vaultVersion) => {
75
- const apiKeyId = newApiKeyId();
76
- const apiKeySecret = randomBytes(OPENLLM_API_KEY_SECRET_BYTES);
74
+ export const mintApiKey = (dek, vaultVersion) => mintApiKeyFrom(dek, vaultVersion, newApiKeyId(), randomBytes(OPENLLM_API_KEY_SECRET_BYTES));
75
+ /**
76
+ * {@link mintApiKey} with a caller-chosen `(id, secret)` — for a key that must
77
+ * be re-derivable (the Routebox's, from the seed). The DEK wrap and the sealed
78
+ * copy still use random nonces, so the row differs per call but the `sk-llm`
79
+ * string is the same. Never zeroes `apiKeySecret`.
80
+ */
81
+ export const mintApiKeyFrom = async (dek, vaultVersion, apiKeyId, apiKeySecret) => {
82
+ if (apiKeySecret.length !== OPENLLM_API_KEY_SECRET_BYTES) {
83
+ throw new Error("API key secret must be 32 bytes");
84
+ }
77
85
  const wrapKey = await deriveApiWrapKey(apiKeySecret, apiKeyId);
78
86
  try {
79
87
  const nonce = randomBytes(NONCE_BYTES);
@@ -7,8 +7,8 @@
7
7
  * so connector and CLI ciphertext are not interchangeable. The server is a
8
8
  * mailbox: it stores only the JSON envelope.
9
9
  */
10
- import { aesGcmDecrypt, aesGcmEncrypt, fromB64, hkdfSha256, randomBytes, toB64, zero, } from "./crypto.js";
11
10
  import { generateResumableX25519Keypair, generateX25519Keypair, importX25519PrivateKey, } from "./handoff.js";
11
+ import { decodeCanonicalB64, openX25519, sealX25519 } from "./x25519-seal.js";
12
12
  export const CLI_AUTH_SEAL_DOMAIN = "openllm-cli-auth-seal-v1";
13
13
  const aad = (binding) => new TextEncoder().encode(JSON.stringify([
14
14
  CLI_AUTH_SEAL_DOMAIN,
@@ -16,59 +16,34 @@ const aad = (binding) => new TextEncoder().encode(JSON.stringify([
16
16
  binding.authorizationId,
17
17
  binding.recipientPublicKeyB64,
18
18
  ]));
19
- const decode = (value) => {
20
- if (typeof value !== "string" ||
21
- !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
22
- throw new Error("Invalid sealed envelope encoding");
23
- const bytes = fromB64(value);
24
- if (toB64(bytes) !== value)
25
- throw new Error("Invalid sealed envelope encoding");
26
- return bytes;
27
- };
28
- const deriveKey = async (privateKey, peerB64, epk, recipient) => {
29
- const peer = await crypto.subtle.importKey("spki", decode(peerB64), { name: "X25519" }, false, []);
30
- const shared = new Uint8Array(await crypto.subtle.deriveBits({ name: "X25519", public: peer }, privateKey, 256));
31
- try {
32
- return await hkdfSha256(shared, new Uint8Array(0), JSON.stringify([CLI_AUTH_SEAL_DOMAIN, epk, recipient]), 32);
33
- }
34
- finally {
35
- zero(shared);
36
- }
37
- };
38
19
  /** Caller retains ownership of plaintext; the temporary copy is wiped. */
39
- export const sealCliAuth = async (binding, plaintext) => {
40
- const eph = await generateX25519Keypair();
41
- const key = await deriveKey(eph.privateKey, binding.recipientPublicKeyB64, eph.publicKeyB64, binding.recipientPublicKeyB64);
42
- const copy = new Uint8Array(plaintext);
43
- try {
44
- const nonce = randomBytes(12);
45
- return {
46
- v: 1,
47
- epk: eph.publicKeyB64,
48
- nonce: toB64(nonce),
49
- ct: toB64(await aesGcmEncrypt(key, nonce, copy, aad(binding))),
50
- };
51
- }
52
- finally {
53
- zero(key);
54
- zero(copy);
55
- }
56
- };
20
+ export const sealCliAuth = async (binding, plaintext) => sealX25519({
21
+ domain: CLI_AUTH_SEAL_DOMAIN,
22
+ recipientB64: binding.recipientPublicKeyB64,
23
+ recipientBytes: decodeCanonicalB64(binding.recipientPublicKeyB64),
24
+ format: "spki",
25
+ aad: aad(binding),
26
+ plaintext,
27
+ });
57
28
  /** Caller owns the returned plaintext and must wipe it when finished. */
58
29
  export const openCliAuth = async (binding, sealed, privateKey) => {
59
30
  if (typeof sealed !== "object" || sealed === null || sealed.v !== 1)
60
31
  throw new Error("Invalid sealed envelope");
61
- const nonce = decode(sealed.nonce);
62
- const ct = decode(sealed.ct);
32
+ const nonce = decodeCanonicalB64(sealed.nonce);
33
+ const ct = decodeCanonicalB64(sealed.ct);
63
34
  if (nonce.length !== 12 || ct.length < 16 || typeof sealed.epk !== "string")
64
35
  throw new Error("Invalid sealed envelope");
65
- const key = await deriveKey(privateKey, sealed.epk, sealed.epk, binding.recipientPublicKeyB64);
66
- try {
67
- return await aesGcmDecrypt(key, nonce, ct, aad(binding));
68
- }
69
- finally {
70
- zero(key);
71
- }
36
+ return openX25519({
37
+ domain: CLI_AUTH_SEAL_DOMAIN,
38
+ privateKey,
39
+ recipientB64: binding.recipientPublicKeyB64,
40
+ epkBytes: decodeCanonicalB64(sealed.epk),
41
+ epkB64: sealed.epk,
42
+ format: "spki",
43
+ aad: aad(binding),
44
+ nonce,
45
+ ct,
46
+ });
72
47
  };
73
48
  /** Alias kept for CLI call-site parity with the old `cli-auth-crypto` names. */
74
49
  export const generateCliAuthKeypair = generateX25519Keypair;
@@ -35,7 +35,6 @@ export const DEVICE_CONTROL_HKDF_SALT = "openllm-device-control-salt-v1";
35
35
  export const DEVICE_CONTROL_KEEP_HKDF_INFO = "openllm-device-control-keep-v1";
36
36
  /** Length of the device-control seed (and of the Routebox key's input). */
37
37
  export const DEVICE_CONTROL_SEED_BYTES = 32;
38
- const SEED_BYTES = DEVICE_CONTROL_SEED_BYTES;
39
38
  /**
40
39
  * `HKDF-SHA256(ikm = BIP39 entropy(phrase), salt = DEVICE_CONTROL_HKDF_SALT,
41
40
  * info = DEVICE_CONTROL_HKDF_INFO, 32)` — the Ed25519 private seed.
@@ -57,7 +56,7 @@ export const deriveDeviceControlSeed = async (phrase) => {
57
56
  * BIP39 entropy, `./seed.ts`) — the same key, for callers that hold the seed
58
57
  * bytes rather than the words. Never zeroes its input.
59
58
  */
60
- export const deriveDeviceControlSeedFromVaultSeed = (vaultSeed) => hkdfSha256(vaultSeed, new TextEncoder().encode(DEVICE_CONTROL_HKDF_SALT), DEVICE_CONTROL_HKDF_INFO, SEED_BYTES);
59
+ export const deriveDeviceControlSeedFromVaultSeed = (vaultSeed) => hkdfSha256(vaultSeed, new TextEncoder().encode(DEVICE_CONTROL_HKDF_SALT), DEVICE_CONTROL_HKDF_INFO, DEVICE_CONTROL_SEED_BYTES);
61
60
  /** The control public key as base64(SPKI DER) — the value daemons pin. */
62
61
  export const deviceControlPublicKeySpkiB64 = (seed) => deviceAccessPublicKeySpkiB64(seed);
63
62
  /**
@@ -74,7 +73,7 @@ export const controlKeepOuterKey = (dek, userId) => {
74
73
  if (userId.length === 0) {
75
74
  throw new Error("control keep requires a non-empty userId");
76
75
  }
77
- return hkdfSha256(dek, new TextEncoder().encode(userId), DEVICE_CONTROL_KEEP_HKDF_INFO, SEED_BYTES);
76
+ return hkdfSha256(dek, new TextEncoder().encode(userId), DEVICE_CONTROL_KEEP_HKDF_INFO, DEVICE_CONTROL_SEED_BYTES);
78
77
  };
79
78
  /**
80
79
  * Sign a rotation statement with the OLD control seed, vouching for `new`.
@@ -1,59 +1,32 @@
1
- import { aesGcmDecrypt, aesGcmEncrypt, fromB64, hkdfSha256, randomBytes, toB64, zero, } from "./crypto.js";
2
- import { generateX25519Keypair } from "./handoff.js";
1
+ import { decodeCanonicalB64, openX25519, sealX25519 } from "./x25519-seal.js";
3
2
  const DOMAIN = "openllm-connector-seal-v1";
4
3
  const aad = (binding) => new TextEncoder().encode(JSON.stringify([DOMAIN, binding.clientId, binding.userId, binding.grantId]));
5
- const decode = (value) => {
6
- if (typeof value !== "string" ||
7
- !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
8
- throw new Error("Invalid sealed envelope encoding");
9
- const bytes = fromB64(value);
10
- if (toB64(bytes) !== value)
11
- throw new Error("Invalid sealed envelope encoding");
12
- return bytes;
13
- };
14
- const deriveKey = async (privateKey, peerB64, epk, recipient) => {
15
- const peer = await crypto.subtle.importKey("spki", decode(peerB64), { name: "X25519" }, false, []);
16
- const shared = new Uint8Array(await crypto.subtle.deriveBits({ name: "X25519", public: peer }, privateKey, 256));
17
- try {
18
- // JSON array framing makes the public-key boundaries unambiguous.
19
- return await hkdfSha256(shared, new Uint8Array(0), JSON.stringify([DOMAIN, epk, recipient]), 32);
20
- }
21
- finally {
22
- zero(shared);
23
- }
24
- };
25
4
  /** Caller retains ownership of plaintext; the temporary copy is wiped. */
26
- export const sealToPublicKey = async (binding, plaintext) => {
27
- const eph = await generateX25519Keypair();
28
- const key = await deriveKey(eph.privateKey, binding.recipientPublicKeyB64, eph.publicKeyB64, binding.recipientPublicKeyB64);
29
- const copy = new Uint8Array(plaintext);
30
- try {
31
- const nonce = randomBytes(12);
32
- return {
33
- v: 1,
34
- epk: eph.publicKeyB64,
35
- nonce: toB64(nonce),
36
- ct: toB64(await aesGcmEncrypt(key, nonce, copy, aad(binding))),
37
- };
38
- }
39
- finally {
40
- zero(key);
41
- zero(copy);
42
- }
43
- };
5
+ export const sealToPublicKey = async (binding, plaintext) => sealX25519({
6
+ domain: DOMAIN,
7
+ recipientB64: binding.recipientPublicKeyB64,
8
+ recipientBytes: decodeCanonicalB64(binding.recipientPublicKeyB64),
9
+ format: "spki",
10
+ aad: aad(binding),
11
+ plaintext,
12
+ });
44
13
  /** Caller owns the returned plaintext and must wipe it when finished. */
45
14
  export const openSealed = async (binding, sealed, privateKey) => {
46
15
  if (typeof sealed !== "object" || sealed === null || sealed.v !== 1)
47
16
  throw new Error("Invalid sealed envelope");
48
- const nonce = decode(sealed.nonce);
49
- const ct = decode(sealed.ct);
17
+ const nonce = decodeCanonicalB64(sealed.nonce);
18
+ const ct = decodeCanonicalB64(sealed.ct);
50
19
  if (nonce.length !== 12 || ct.length < 16 || typeof sealed.epk !== "string")
51
20
  throw new Error("Invalid sealed envelope");
52
- const key = await deriveKey(privateKey, sealed.epk, sealed.epk, binding.recipientPublicKeyB64);
53
- try {
54
- return await aesGcmDecrypt(key, nonce, ct, aad(binding));
55
- }
56
- finally {
57
- zero(key);
58
- }
21
+ return openX25519({
22
+ domain: DOMAIN,
23
+ privateKey,
24
+ recipientB64: binding.recipientPublicKeyB64,
25
+ epkBytes: decodeCanonicalB64(sealed.epk),
26
+ epkB64: sealed.epk,
27
+ format: "spki",
28
+ aad: aad(binding),
29
+ nonce,
30
+ ct,
31
+ });
59
32
  };
@@ -1,3 +1,16 @@
1
- export declare const ROUTEBOX_HOME_HKDF_INFO = "openllm-routebox-home-v1";
1
+ import type { TMintedApiKey } from "./api-key.js";
2
+ export declare const ROUTEBOX_HOME_HKDF_INFO = "openllm-routebox-home-v2";
3
+ export declare const ROUTEBOX_KEY_ID_HKDF_INFO = "openllm-routebox-key-id-v1";
4
+ export declare const ROUTEBOX_KEY_SECRET_HKDF_INFO = "openllm-routebox-key-secret-v1";
2
5
  /** Derive the box's home key; the caller must zero the returned bytes. */
3
- export declare const deriveRouteboxHomeKey: (controlSeed: Uint8Array, keyId: string) => Promise<Uint8Array>;
6
+ export declare const deriveRouteboxHomeKey: (controlSeed: Uint8Array, subjectId: string, epoch: number) => Promise<Uint8Array>;
7
+ /** The box's API key id, in the ordinary base64url key-id encoding. */
8
+ export declare const deriveRouteboxKeyId: (controlSeed: Uint8Array, subjectId: string, epoch: number) => Promise<string>;
9
+ /** The box's API key secret; the caller must zero the returned bytes. */
10
+ export declare const deriveRouteboxKeySecret: (controlSeed: Uint8Array, subjectId: string, epoch: number) => Promise<Uint8Array>;
11
+ /**
12
+ * Mint the box's API key deterministically: a normal `api_keys` row whose id
13
+ * and `sk-llm` string are the same every time for this seed and machine (only
14
+ * the DEK-wrap nonces are random).
15
+ */
16
+ export declare const mintRouteboxApiKey: (dek: Uint8Array, vaultVersion: number, controlSeed: Uint8Array, subjectId: string, epoch: number) => Promise<TMintedApiKey>;
@@ -1,35 +1,79 @@
1
1
  /**
2
- * The Routebox's home key: what opens its encrypted home (LUKS).
2
+ * The Routebox's keys, all derived from the account's device-control seed and
3
+ * the machine's GalaxyGate SUBJECT id (stable for the machine's life, across
4
+ * deployments, resets and re-claims):
3
5
  *
4
- * Derived from the box API key's DEVICE ANCHOR secret — the per-key pair
5
- * secret `HKDF(device-control seed, key id)` (`device-anchor.ts`) that every
6
- * anchored device already holds — under its own label, so the home key and the
7
- * anchor's other uses never coincide. The device-control seed is itself
8
- * `HKDF(vault seed)`, held by an unlocked browser and by nothing else: no API
9
- * key, daemon or server. So the home key is deterministic from the recovery
10
- * phrase, stored nowhere, re-derivable by the owner's browser after every
11
- * reboot, different for every key, and gone with a vault rotation. A box that
12
- * is reset or replaced gets a new key, so a new home key; deleting the key is
13
- * the revocation.
6
+ * - the box's API key id (10 bytes, the normal key-id encoding),
7
+ * - the box's API key secret (32 bytes),
8
+ * - the home key that opens its encrypted home (LUKS).
9
+ *
10
+ * all also depend on the box's reset epoch (see `saltOf`).
11
+ *
12
+ * Each is `HKDF-SHA256(seed, utf8(subject id), <own info>, n)`, so they never
13
+ * coincide. The device-control seed is itself `HKDF(vault seed)`, held by an
14
+ * unlocked browser and by nothing else: no API key, daemon or server. So any
15
+ * deployment, given the same user's phrase, rebuilds the same `sk-llm` and the
16
+ * same home key — the key already on the box keeps working after a takeover.
17
+ * Different subject or seed, different keys; a vault rotation changes the seed
18
+ * and so everything.
14
19
  *
15
20
  * Deliberately NOT re-exported from `vault/index.ts`: the `openllm` binary
16
- * imports that barrel, and a box only ever receives this key. Import it by
21
+ * imports that barrel, and a box only ever receives these keys. Import by
17
22
  * subpath: `@openllmsh/sdk/vault/routebox-key`.
18
23
  */
19
- import { hkdfSha256, zero } from "./crypto.js";
20
- import { deriveDevicePairSecret } from "./device-anchor.js";
24
+ import { OPENLLM_API_KEY_ID_BYTES, OPENLLM_API_KEY_SECRET_BYTES, } from "@openllmsh/sdk/protocol";
25
+ import { mintApiKeyFrom } from "./api-key.js";
26
+ import { hkdfSha256, toB64Url, zero } from "./crypto.js";
21
27
  import { DEVICE_CONTROL_SEED_BYTES } from "./device-control.js";
22
- export const ROUTEBOX_HOME_HKDF_INFO = "openllm-routebox-home-v1";
23
- /** Derive the box's home key; the caller must zero the returned bytes. */
24
- export const deriveRouteboxHomeKey = async (controlSeed, keyId) => {
28
+ export const ROUTEBOX_HOME_HKDF_INFO = "openllm-routebox-home-v2";
29
+ export const ROUTEBOX_KEY_ID_HKDF_INFO = "openllm-routebox-key-id-v1";
30
+ export const ROUTEBOX_KEY_SECRET_HKDF_INFO = "openllm-routebox-key-secret-v1";
31
+ /**
32
+ * The salt: the subject id and the box's reset epoch. A Reset increments the
33
+ * epoch, so it derives a NEW key id, secret and home key (an old `sk-llm` is
34
+ * never re-minted); a takeover reads the epoch from the machine's name and so
35
+ * rebuilds the same ones.
36
+ */
37
+ const saltOf = (subjectId, epoch) => {
38
+ if (!Number.isInteger(epoch) || epoch < 0) {
39
+ throw new Error("Routebox reset epoch must be a non-negative integer");
40
+ }
41
+ return new TextEncoder().encode(`${subjectId}|e${epoch}`);
42
+ };
43
+ const derive = async (controlSeed, subjectId, epoch, info, length) => {
25
44
  if (controlSeed.length !== DEVICE_CONTROL_SEED_BYTES) {
26
45
  throw new Error("invalid device-control seed length");
27
46
  }
28
- const pairSecret = await deriveDevicePairSecret(controlSeed, keyId);
47
+ if (subjectId.length === 0)
48
+ throw new Error("Routebox key needs a subject id");
49
+ return hkdfSha256(controlSeed, saltOf(subjectId, epoch), info, length);
50
+ };
51
+ /** Derive the box's home key; the caller must zero the returned bytes. */
52
+ export const deriveRouteboxHomeKey = (controlSeed, subjectId, epoch) => derive(controlSeed, subjectId, epoch, ROUTEBOX_HOME_HKDF_INFO, 32);
53
+ /** The box's API key id, in the ordinary base64url key-id encoding. */
54
+ export const deriveRouteboxKeyId = async (controlSeed, subjectId, epoch) => {
55
+ const bytes = await derive(controlSeed, subjectId, epoch, ROUTEBOX_KEY_ID_HKDF_INFO, OPENLLM_API_KEY_ID_BYTES);
56
+ try {
57
+ return toB64Url(bytes);
58
+ }
59
+ finally {
60
+ zero(bytes);
61
+ }
62
+ };
63
+ /** The box's API key secret; the caller must zero the returned bytes. */
64
+ export const deriveRouteboxKeySecret = (controlSeed, subjectId, epoch) => derive(controlSeed, subjectId, epoch, ROUTEBOX_KEY_SECRET_HKDF_INFO, OPENLLM_API_KEY_SECRET_BYTES);
65
+ /**
66
+ * Mint the box's API key deterministically: a normal `api_keys` row whose id
67
+ * and `sk-llm` string are the same every time for this seed and machine (only
68
+ * the DEK-wrap nonces are random).
69
+ */
70
+ export const mintRouteboxApiKey = async (dek, vaultVersion, controlSeed, subjectId, epoch) => {
71
+ const id = await deriveRouteboxKeyId(controlSeed, subjectId, epoch);
72
+ const secret = await deriveRouteboxKeySecret(controlSeed, subjectId, epoch);
29
73
  try {
30
- return await hkdfSha256(pairSecret, new Uint8Array(0), ROUTEBOX_HOME_HKDF_INFO, 32);
74
+ return await mintApiKeyFrom(dek, vaultVersion, id, secret);
31
75
  }
32
76
  finally {
33
- zero(pairSecret);
77
+ zero(secret);
34
78
  }
35
79
  };
@@ -19,7 +19,8 @@
19
19
  * The box side mirrors `open_unlock` in
20
20
  * `packages/api/lib/routebox/box-agent.ts` (Python).
21
21
  */
22
- import { aesGcmDecrypt, aesGcmEncrypt, fromB64, hkdfSha256, randomBytes, toB64, zero, } from "./crypto.js";
22
+ import { fromB64, toB64, zero } from "./crypto.js";
23
+ import { openX25519, sealX25519 } from "./x25519-seal.js";
23
24
  export const ROUTEBOX_SEAL_DOMAIN = "openllm-routebox-seal-v1";
24
25
  const encoder = new TextEncoder();
25
26
  /** Canonical associated data; the Python side builds the same bytes. */
@@ -39,37 +40,21 @@ const raw32 = (b64, what) => {
39
40
  }
40
41
  return bytes;
41
42
  };
42
- const deriveKey = async (privateKey, peerRaw, epkB64, recipientB64) => {
43
- const peer = await crypto.subtle.importKey("raw", peerRaw, { name: "X25519" }, false, []);
44
- const shared = new Uint8Array(await crypto.subtle.deriveBits({ name: "X25519", public: peer }, privateKey, 256));
45
- try {
46
- return await hkdfSha256(shared, new Uint8Array(0), JSON.stringify([ROUTEBOX_SEAL_DOMAIN, epkB64, recipientB64]), 32);
47
- }
48
- finally {
49
- zero(shared);
50
- }
51
- };
52
43
  /** Seal `unlock` to the boot in `binding`. */
53
44
  export const sealRouteboxUnlock = async (binding, unlock) => {
54
45
  raw32(binding.challengeB64, "challenge");
55
- const recipient = raw32(binding.bootPubkeyB64, "boot public key");
56
- const eph = (await crypto.subtle.generateKey({ name: "X25519" }, true, [
57
- "deriveBits",
58
- ]));
59
- const epkB64 = toB64(new Uint8Array(await crypto.subtle.exportKey("raw", eph.publicKey)));
60
- const key = await deriveKey(eph.privateKey, recipient, epkB64, binding.bootPubkeyB64);
61
46
  const plaintext = encoder.encode(JSON.stringify(unlock));
62
47
  try {
63
- const nonce = randomBytes(12);
64
- return {
65
- v: 1,
66
- epk: epkB64,
67
- nonce: toB64(nonce),
68
- ct: toB64(await aesGcmEncrypt(key, nonce, plaintext, routeboxSealAad(binding))),
69
- };
48
+ return await sealX25519({
49
+ domain: ROUTEBOX_SEAL_DOMAIN,
50
+ recipientB64: binding.bootPubkeyB64,
51
+ recipientBytes: raw32(binding.bootPubkeyB64, "boot public key"),
52
+ format: "raw",
53
+ aad: routeboxSealAad(binding),
54
+ plaintext,
55
+ });
70
56
  }
71
57
  finally {
72
- zero(key);
73
58
  zero(plaintext);
74
59
  }
75
60
  };
@@ -77,17 +62,30 @@ export const sealRouteboxUnlock = async (binding, unlock) => {
77
62
  export const openRouteboxUnlock = async (binding, envelope, bootPrivateKey) => {
78
63
  if (envelope.v !== 1)
79
64
  throw new Error("unknown envelope version");
80
- const key = await deriveKey(bootPrivateKey, raw32(envelope.epk, "ephemeral key"), envelope.epk, binding.bootPubkeyB64);
65
+ const plaintext = await openX25519({
66
+ domain: ROUTEBOX_SEAL_DOMAIN,
67
+ privateKey: bootPrivateKey,
68
+ recipientB64: binding.bootPubkeyB64,
69
+ epkBytes: raw32(envelope.epk, "ephemeral key"),
70
+ epkB64: envelope.epk,
71
+ format: "raw",
72
+ aad: routeboxSealAad(binding),
73
+ nonce: fromB64(envelope.nonce),
74
+ ct: fromB64(envelope.ct),
75
+ });
81
76
  try {
82
- const plaintext = await aesGcmDecrypt(key, fromB64(envelope.nonce), fromB64(envelope.ct), routeboxSealAad(binding));
83
- try {
84
- return JSON.parse(new TextDecoder().decode(plaintext));
85
- }
86
- finally {
87
- zero(plaintext);
77
+ const parsed = JSON.parse(new TextDecoder().decode(plaintext));
78
+ if (typeof parsed !== "object" ||
79
+ parsed === null ||
80
+ !("home_key" in parsed) ||
81
+ !("api_key" in parsed) ||
82
+ typeof parsed.home_key !== "string" ||
83
+ typeof parsed.api_key !== "string") {
84
+ throw new Error("malformed routebox unlock payload");
88
85
  }
86
+ return { home_key: parsed.home_key, api_key: parsed.api_key };
89
87
  }
90
88
  finally {
91
- zero(key);
89
+ zero(plaintext);
92
90
  }
93
91
  };
@@ -0,0 +1,48 @@
1
+ /**
2
+ * The one ephemeral-X25519 + HKDF-SHA-256 + AES-256-GCM seal behind
3
+ * `public-key-seal.ts`, `cli-auth-seal.ts` and `routebox-seal.ts`.
4
+ *
5
+ * Callers differ only in their domain string, associated data and the
6
+ * encoding of the recipient / ephemeral public key (`spki` DER or `raw`
7
+ * 32 bytes); the key derivation and ciphertext layout are shared, so every
8
+ * wire format stays exactly as each seal documents it.
9
+ */
10
+ export type TX25519KeyFormat = "spki" | "raw";
11
+ export type TX25519Sealed = {
12
+ readonly v: 1;
13
+ readonly epk: string;
14
+ readonly nonce: string;
15
+ readonly ct: string;
16
+ };
17
+ /** The HKDF + ECDH half: both sides derive the same 32-byte AES key. */
18
+ export declare const deriveX25519SealKey: (params: {
19
+ readonly domain: string;
20
+ readonly privateKey: CryptoKey;
21
+ readonly peerKeyBytes: Uint8Array;
22
+ readonly peerFormat: TX25519KeyFormat;
23
+ readonly epkB64: string;
24
+ readonly recipientB64: string;
25
+ }) => Promise<Uint8Array>;
26
+ /** Seal `plaintext` to `recipientB64`; the caller keeps ownership of it. */
27
+ export declare const sealX25519: (params: {
28
+ readonly domain: string;
29
+ readonly recipientB64: string;
30
+ readonly recipientBytes: Uint8Array;
31
+ readonly format: TX25519KeyFormat;
32
+ readonly aad: Uint8Array;
33
+ readonly plaintext: Uint8Array;
34
+ }) => Promise<TX25519Sealed>;
35
+ /** Open an envelope; the caller owns the returned plaintext and wipes it. */
36
+ export declare const openX25519: (params: {
37
+ readonly domain: string;
38
+ readonly privateKey: CryptoKey;
39
+ readonly recipientB64: string;
40
+ readonly epkBytes: Uint8Array;
41
+ readonly epkB64: string;
42
+ readonly format: TX25519KeyFormat;
43
+ readonly aad: Uint8Array;
44
+ readonly nonce: Uint8Array;
45
+ readonly ct: Uint8Array;
46
+ }) => Promise<Uint8Array>;
47
+ /** Strict canonical-base64 decode shared by the SPKI-format seals. */
48
+ export declare const decodeCanonicalB64: (value: unknown) => Uint8Array;
@@ -0,0 +1,78 @@
1
+ /**
2
+ * The one ephemeral-X25519 + HKDF-SHA-256 + AES-256-GCM seal behind
3
+ * `public-key-seal.ts`, `cli-auth-seal.ts` and `routebox-seal.ts`.
4
+ *
5
+ * Callers differ only in their domain string, associated data and the
6
+ * encoding of the recipient / ephemeral public key (`spki` DER or `raw`
7
+ * 32 bytes); the key derivation and ciphertext layout are shared, so every
8
+ * wire format stays exactly as each seal documents it.
9
+ */
10
+ import { aesGcmDecrypt, aesGcmEncrypt, fromB64, hkdfSha256, randomBytes, toB64, zero, } from "./crypto.js";
11
+ /** The HKDF + ECDH half: both sides derive the same 32-byte AES key. */
12
+ export const deriveX25519SealKey = async (params) => {
13
+ const peer = await crypto.subtle.importKey(params.peerFormat, params.peerKeyBytes, { name: "X25519" }, false, []);
14
+ const shared = new Uint8Array(await crypto.subtle.deriveBits({ name: "X25519", public: peer }, params.privateKey, 256));
15
+ try {
16
+ // JSON array framing makes the public-key boundaries unambiguous.
17
+ return await hkdfSha256(shared, new Uint8Array(0), JSON.stringify([params.domain, params.epkB64, params.recipientB64]), 32);
18
+ }
19
+ finally {
20
+ zero(shared);
21
+ }
22
+ };
23
+ /** Seal `plaintext` to `recipientB64`; the caller keeps ownership of it. */
24
+ export const sealX25519 = async (params) => {
25
+ const eph = (await crypto.subtle.generateKey({ name: "X25519" }, false, [
26
+ "deriveBits",
27
+ ]));
28
+ const epk = toB64(new Uint8Array(await crypto.subtle.exportKey(params.format, eph.publicKey)));
29
+ const key = await deriveX25519SealKey({
30
+ domain: params.domain,
31
+ privateKey: eph.privateKey,
32
+ peerKeyBytes: params.recipientBytes,
33
+ peerFormat: params.format,
34
+ epkB64: epk,
35
+ recipientB64: params.recipientB64,
36
+ });
37
+ const copy = new Uint8Array(params.plaintext);
38
+ try {
39
+ const nonce = randomBytes(12);
40
+ return {
41
+ v: 1,
42
+ epk,
43
+ nonce: toB64(nonce),
44
+ ct: toB64(await aesGcmEncrypt(key, nonce, copy, params.aad)),
45
+ };
46
+ }
47
+ finally {
48
+ zero(key);
49
+ zero(copy);
50
+ }
51
+ };
52
+ /** Open an envelope; the caller owns the returned plaintext and wipes it. */
53
+ export const openX25519 = async (params) => {
54
+ const key = await deriveX25519SealKey({
55
+ domain: params.domain,
56
+ privateKey: params.privateKey,
57
+ peerKeyBytes: params.epkBytes,
58
+ peerFormat: params.format,
59
+ epkB64: params.epkB64,
60
+ recipientB64: params.recipientB64,
61
+ });
62
+ try {
63
+ return await aesGcmDecrypt(key, params.nonce, params.ct, params.aad);
64
+ }
65
+ finally {
66
+ zero(key);
67
+ }
68
+ };
69
+ /** Strict canonical-base64 decode shared by the SPKI-format seals. */
70
+ export const decodeCanonicalB64 = (value) => {
71
+ if (typeof value !== "string" ||
72
+ !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
73
+ throw new Error("Invalid sealed envelope encoding");
74
+ const bytes = fromB64(value);
75
+ if (toB64(bytes) !== value)
76
+ throw new Error("Invalid sealed envelope encoding");
77
+ return bytes;
78
+ };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@openllmsh/sdk",
3
- "version": "2.10.19-alpha.1",
3
+ "version": "2.10.19-alpha.3",
4
4
  "private": false,
5
5
  "description": "The OpenLLM SDK: typed API contracts, wire-format adapters, the device tunnel, client-side vault crypto, the OpenAPI spec and MCP tools.",
6
6
  "keywords": [