dsh-agent-sdk-bridge 1.1.3 → 1.1.5

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/lib/index.js CHANGED
@@ -4004,6 +4004,30 @@ var CodeBuddyAuth = class {
4004
4004
  }
4005
4005
  }
4006
4006
  };
4007
+ /** A token count as a non-negative whole number; anything unusable becomes 0. */
4008
+ function countOf(value) {
4009
+ return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.ceil(value) : 0;
4010
+ }
4011
+ /** Whether one usage frame actually measured a prompt. */
4012
+ function measuredPrompt(usage) {
4013
+ return usage !== void 0 && (countOf(usage.input_tokens) > 0 || countOf(usage.cache_read_input_tokens) > 0 || countOf(usage.cache_creation_input_tokens) > 0);
4014
+ }
4015
+ /**
4016
+ * Fold one `message_delta` usage into the turn's reading.
4017
+ *
4018
+ * The delta is cumulative for its own message and carries the final output
4019
+ * count. Not every transport repeats the prompt fields on it, so the last
4020
+ * measured values are kept rather than letting a later frame erase them.
4021
+ */
4022
+ function mergeTurnUsage(previous, next) {
4023
+ const output = typeof next.output_tokens === "number" && Number.isFinite(next.output_tokens) ? next.output_tokens : previous?.output_tokens ?? 0;
4024
+ return {
4025
+ input_tokens: countOf(next.input_tokens) > 0 ? next.input_tokens : previous?.input_tokens ?? 0,
4026
+ output_tokens: output,
4027
+ cache_read_input_tokens: next.cache_read_input_tokens ?? previous?.cache_read_input_tokens ?? 0,
4028
+ cache_creation_input_tokens: next.cache_creation_input_tokens ?? previous?.cache_creation_input_tokens ?? 0
4029
+ };
4030
+ }
4007
4031
  /**
4008
4032
  * One warm CodeBuddy session for a host session id.
4009
4033
  *
@@ -4031,7 +4055,16 @@ var CodeBuddySession = class {
4031
4055
  callCounter = 0;
4032
4056
  callNonce = randomUUID().slice(0, 8);
4033
4057
  lastUsage;
4034
- resultUsage;
4058
+ /**
4059
+ * The last prompt-side buckets a request actually measured.
4060
+ *
4061
+ * Kept across turns: a turn can end without a usable usage frame (aborted
4062
+ * before the first delta, or a transport that only sends the cumulative
4063
+ * result). Reusing the last real reading keeps the host's context pressure
4064
+ * at the provider's actual prompt instead of collapsing it to the CLI's
4065
+ * startup overhead.
4066
+ */
4067
+ lastPromptUsage;
4035
4068
  /**
4036
4069
  * Ids of assistant messages whose streaming events this session consumed.
4037
4070
  *
@@ -4253,7 +4286,7 @@ var CodeBuddySession = class {
4253
4286
  const event = message.event;
4254
4287
  if (event.type === "message_start") {
4255
4288
  const usage = event.message.usage;
4256
- if (usage !== void 0) this.lastUsage = usage;
4289
+ if (measuredPrompt(usage)) this.lastUsage = usage;
4257
4290
  this.rememberStreamedMessage(event.message.id);
4258
4291
  return;
4259
4292
  }
@@ -4359,7 +4392,7 @@ var CodeBuddySession = class {
4359
4392
  }
4360
4393
  if (event.type === "message_delta") {
4361
4394
  const usage = event.usage;
4362
- if (usage !== void 0) this.lastUsage = usage;
4395
+ if (usage !== void 0) this.lastUsage = mergeTurnUsage(this.lastUsage, usage);
4363
4396
  return;
4364
4397
  }
4365
4398
  if (event.type === "message_stop") {
@@ -4398,7 +4431,6 @@ var CodeBuddySession = class {
4398
4431
  return;
4399
4432
  }
4400
4433
  if (message.type === "result") {
4401
- this.resultUsage = message.usage;
4402
4434
  if (this.abortPending) {
4403
4435
  this.endTurn({
4404
4436
  kind: "aborted",
@@ -4456,7 +4488,6 @@ var CodeBuddySession = class {
4456
4488
  this.inputChars = 0;
4457
4489
  this.output.reset();
4458
4490
  this.lastUsage = void 0;
4459
- this.resultUsage = void 0;
4460
4491
  this.turnEndKind = void 0;
4461
4492
  }
4462
4493
  emit(chunk) {
@@ -4469,29 +4500,48 @@ var CodeBuddySession = class {
4469
4500
  this.output.addOutput(text);
4470
4501
  }
4471
4502
  usage() {
4472
- const metered = this.lastUsage ?? this.resultUsage;
4473
- if (metered !== void 0) {
4474
- const cacheRead = metered.cache_read_input_tokens ?? 0;
4475
- const cacheWrite = metered.cache_creation_input_tokens ?? 0;
4476
- const input = Math.max(0, metered.input_tokens - cacheRead - cacheWrite);
4477
- const output = this.output.usage();
4503
+ const metered = this.lastUsage;
4504
+ const local = this.output.usage();
4505
+ const measuredOutput = countOf(metered?.output_tokens);
4506
+ const outputTokens = measuredOutput > 0 ? measuredOutput : Math.max(1, Math.ceil(local.outputTokens));
4507
+ const reasoning = local.reasoningTokens === void 0 ? {} : { reasoningTokens: Math.min(outputTokens, Math.max(1, Math.ceil(local.reasoningTokens))) };
4508
+ if (metered !== void 0 && countOf(metered.input_tokens) > 0) {
4509
+ const cacheRead = countOf(metered.cache_read_input_tokens);
4510
+ const cacheWrite = countOf(metered.cache_creation_input_tokens);
4511
+ const inputTokens = Math.max(0, countOf(metered.input_tokens) - cacheRead - cacheWrite);
4512
+ this.lastPromptUsage = {
4513
+ inputTokens,
4514
+ cacheReadTokens: cacheRead,
4515
+ cacheWriteTokens: cacheWrite
4516
+ };
4478
4517
  return {
4479
- inputTokens: input,
4480
- outputTokens: output.outputTokens,
4481
- ...output.reasoningTokens === void 0 ? {} : { reasoningTokens: output.reasoningTokens },
4518
+ inputTokens,
4519
+ outputTokens,
4520
+ ...reasoning,
4482
4521
  cacheReadTokens: cacheRead,
4483
4522
  cacheWriteTokens: cacheWrite,
4484
- totalTokens: input + cacheRead + cacheWrite + output.outputTokens
4523
+ totalTokens: inputTokens + cacheRead + cacheWrite + outputTokens
4485
4524
  };
4486
4525
  }
4487
- const input = Math.max(1, estimateTextTokens(this.inputChars, 0));
4488
- const output = this.output.usage();
4526
+ if (this.lastPromptUsage !== void 0) {
4527
+ const prompt = this.lastPromptUsage;
4528
+ return {
4529
+ inputTokens: prompt.inputTokens,
4530
+ outputTokens,
4531
+ ...reasoning,
4532
+ cacheReadTokens: prompt.cacheReadTokens,
4533
+ cacheWriteTokens: prompt.cacheWriteTokens,
4534
+ totalTokens: prompt.inputTokens + prompt.cacheReadTokens + prompt.cacheWriteTokens + outputTokens
4535
+ };
4536
+ }
4537
+ const inputTokens = Math.max(1, Math.ceil(estimateTextTokens(this.inputChars, 0)));
4489
4538
  return {
4490
- inputTokens: input,
4491
- outputTokens: Math.max(1, output.outputTokens),
4539
+ inputTokens,
4540
+ outputTokens,
4541
+ ...reasoning,
4492
4542
  cacheReadTokens: 0,
4493
4543
  cacheWriteTokens: 0,
4494
- totalTokens: input + Math.max(1, output.outputTokens)
4544
+ totalTokens: inputTokens + outputTokens
4495
4545
  };
4496
4546
  }
4497
4547
  endTurn(reason) {
@@ -208,7 +208,16 @@ export declare class CodeBuddySession {
208
208
  private callCounter;
209
209
  private readonly callNonce;
210
210
  private lastUsage;
211
- private resultUsage;
211
+ /**
212
+ * The last prompt-side buckets a request actually measured.
213
+ *
214
+ * Kept across turns: a turn can end without a usable usage frame (aborted
215
+ * before the first delta, or a transport that only sends the cumulative
216
+ * result). Reusing the last real reading keeps the host's context pressure
217
+ * at the provider's actual prompt instead of collapsing it to the CLI's
218
+ * startup overhead.
219
+ */
220
+ private lastPromptUsage;
212
221
  /**
213
222
  * Ids of assistant messages whose streaming events this session consumed.
214
223
  *
package/package.json CHANGED
@@ -2,7 +2,7 @@
2
2
  "name": "dsh-agent-sdk-bridge",
3
3
  "displayName": "Agent SDK Bridge",
4
4
  "description": "DeepSeek Harness LLM adapter bridge for Qoder CN, Qoder International, Tencent CodeBuddy and MiniMax Code subscriptions. It reuses each provider's own SDK or official ACP server and CLI login, shows available quota, and exposes per-provider settings pages with independent international and mainland login regions.",
5
- "version": "1.1.3",
5
+ "version": "1.1.5",
6
6
  "type": "module",
7
7
  "license": "MIT",
8
8
  "author": "k1-h2",
package/src/codebuddy.ts CHANGED
@@ -824,6 +824,38 @@ interface PendingTool {
824
824
  /** Per-turn output accounting shared with the Qoder session. */
825
825
  type TurnUsage = { input_tokens: number, output_tokens: number, cache_read_input_tokens?: number | null, cache_creation_input_tokens?: number | null }
826
826
 
827
+ /** A token count as a non-negative whole number; anything unusable becomes 0. */
828
+ function countOf(value: unknown): number {
829
+ return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.ceil(value) : 0
830
+ }
831
+
832
+ /** Whether one usage frame actually measured a prompt. */
833
+ function measuredPrompt(usage: TurnUsage | undefined): usage is TurnUsage {
834
+ return usage !== undefined
835
+ && (countOf(usage.input_tokens) > 0
836
+ || countOf(usage.cache_read_input_tokens) > 0
837
+ || countOf(usage.cache_creation_input_tokens) > 0)
838
+ }
839
+
840
+ /**
841
+ * Fold one `message_delta` usage into the turn's reading.
842
+ *
843
+ * The delta is cumulative for its own message and carries the final output
844
+ * count. Not every transport repeats the prompt fields on it, so the last
845
+ * measured values are kept rather than letting a later frame erase them.
846
+ */
847
+ function mergeTurnUsage(previous: TurnUsage | undefined, next: TurnUsage): TurnUsage {
848
+ const output = typeof next.output_tokens === 'number' && Number.isFinite(next.output_tokens)
849
+ ? next.output_tokens
850
+ : previous?.output_tokens ?? 0
851
+ return {
852
+ input_tokens: countOf(next.input_tokens) > 0 ? next.input_tokens : previous?.input_tokens ?? 0,
853
+ output_tokens: output,
854
+ cache_read_input_tokens: next.cache_read_input_tokens ?? previous?.cache_read_input_tokens ?? 0,
855
+ cache_creation_input_tokens: next.cache_creation_input_tokens ?? previous?.cache_creation_input_tokens ?? 0,
856
+ }
857
+ }
858
+
827
859
  /**
828
860
  * One warm CodeBuddy session for a host session id.
829
861
  *
@@ -850,7 +882,16 @@ export class CodeBuddySession {
850
882
  private callCounter = 0
851
883
  private readonly callNonce = randomUUID().slice(0, 8)
852
884
  private lastUsage: TurnUsage | undefined
853
- private resultUsage: TurnUsage | undefined
885
+ /**
886
+ * The last prompt-side buckets a request actually measured.
887
+ *
888
+ * Kept across turns: a turn can end without a usable usage frame (aborted
889
+ * before the first delta, or a transport that only sends the cumulative
890
+ * result). Reusing the last real reading keeps the host's context pressure
891
+ * at the provider's actual prompt instead of collapsing it to the CLI's
892
+ * startup overhead.
893
+ */
894
+ private lastPromptUsage: { inputTokens: number, cacheReadTokens: number, cacheWriteTokens: number } | undefined
854
895
  /**
855
896
  * Ids of assistant messages whose streaming events this session consumed.
856
897
  *
@@ -1066,7 +1107,10 @@ export class CodeBuddySession {
1066
1107
  const event = message.event
1067
1108
  if (event.type === 'message_start') {
1068
1109
  const usage = (event.message as { usage?: TurnUsage }).usage
1069
- if (usage !== undefined) this.lastUsage = usage
1110
+ // CodeBuddy reports all-zero counts here; the real prompt arrives on
1111
+ // message_delta. Only a frame that measured something may replace the
1112
+ // turn's reading, or an interrupted turn would report a zero prompt.
1113
+ if (measuredPrompt(usage)) this.lastUsage = usage
1070
1114
  // Remember which message this stream belongs to. A tool round ends the
1071
1115
  // host turn at `message_stop` (waiting for `result` would deadlock:
1072
1116
  // the CLI only finishes after the host returns the tool result), so
@@ -1138,7 +1182,7 @@ export class CodeBuddySession {
1138
1182
  }
1139
1183
  if (event.type === 'message_delta') {
1140
1184
  const usage = (event as { usage?: TurnUsage }).usage
1141
- if (usage !== undefined) this.lastUsage = usage
1185
+ if (usage !== undefined) this.lastUsage = mergeTurnUsage(this.lastUsage, usage)
1142
1186
  return
1143
1187
  }
1144
1188
  if (event.type === 'message_stop') {
@@ -1172,7 +1216,9 @@ export class CodeBuddySession {
1172
1216
  return
1173
1217
  }
1174
1218
  if (message.type === 'result') {
1175
- this.resultUsage = message.usage as TurnUsage
1219
+ // `result.usage` is cumulative for the whole inner session (verified:
1220
+ // the inputs of every request so far are summed), so it is never the
1221
+ // current prompt. The per-request reading is the last message_delta's.
1176
1222
  if (this.abortPending) {
1177
1223
  this.endTurn({ kind: 'aborted', failure: { message: 'CodeBuddy turn aborted by host', code: 'ABORTED' } })
1178
1224
  return
@@ -1214,7 +1260,6 @@ export class CodeBuddySession {
1214
1260
  this.inputChars = 0
1215
1261
  this.output.reset()
1216
1262
  this.lastUsage = undefined
1217
- this.resultUsage = undefined
1218
1263
  this.turnEndKind = undefined
1219
1264
  }
1220
1265
 
@@ -1227,29 +1272,57 @@ export class CodeBuddySession {
1227
1272
  }
1228
1273
 
1229
1274
  private usage(): TokenUsage {
1230
- const metered = this.lastUsage ?? this.resultUsage
1231
- if (metered !== undefined) {
1232
- const cacheRead = metered.cache_read_input_tokens ?? 0
1233
- const cacheWrite = metered.cache_creation_input_tokens ?? 0
1234
- const input = Math.max(0, metered.input_tokens - cacheRead - cacheWrite)
1235
- const output = this.output.usage()
1275
+ const metered = this.lastUsage
1276
+ const local = this.output.usage()
1277
+ // The provider counts output exactly. The character estimate is only for
1278
+ // turns whose stream carried no usage at all (older transports, aborts).
1279
+ const measuredOutput = countOf(metered?.output_tokens)
1280
+ const outputTokens = measuredOutput > 0 ? measuredOutput : Math.max(1, Math.ceil(local.outputTokens))
1281
+ const reasoning = local.reasoningTokens === undefined
1282
+ ? {}
1283
+ : { reasoningTokens: Math.min(outputTokens, Math.max(1, Math.ceil(local.reasoningTokens))) }
1284
+
1285
+ if (metered !== undefined && countOf(metered.input_tokens) > 0) {
1286
+ const cacheRead = countOf(metered.cache_read_input_tokens)
1287
+ const cacheWrite = countOf(metered.cache_creation_input_tokens)
1288
+ // `input_tokens` includes cache traffic: CodeBuddy's own modelUsage
1289
+ // reports inputTokens = input_tokens - cache_read (verified live), so
1290
+ // the harness's disjoint buckets are the remainder plus the cache ones.
1291
+ const inputTokens = Math.max(0, countOf(metered.input_tokens) - cacheRead - cacheWrite)
1292
+ this.lastPromptUsage = { inputTokens, cacheReadTokens: cacheRead, cacheWriteTokens: cacheWrite }
1236
1293
  return {
1237
- inputTokens: input,
1238
- outputTokens: output.outputTokens,
1239
- ...output.reasoningTokens === undefined ? {} : { reasoningTokens: output.reasoningTokens },
1294
+ inputTokens,
1295
+ outputTokens,
1296
+ ...reasoning,
1240
1297
  cacheReadTokens: cacheRead,
1241
1298
  cacheWriteTokens: cacheWrite,
1242
- totalTokens: input + cacheRead + cacheWrite + output.outputTokens,
1299
+ totalTokens: inputTokens + cacheRead + cacheWrite + outputTokens,
1243
1300
  }
1244
1301
  }
1245
- const input = Math.max(1, estimateTextTokens(this.inputChars, 0))
1246
- const output = this.output.usage()
1302
+
1303
+ if (this.lastPromptUsage !== undefined) {
1304
+ // No usable usage frame this turn. Reuse the provider's last measured
1305
+ // prompt: reporting zero would collapse the context ring, and `result`
1306
+ // is session-cumulative, so it can never stand in for one request.
1307
+ const prompt = this.lastPromptUsage
1308
+ return {
1309
+ inputTokens: prompt.inputTokens,
1310
+ outputTokens,
1311
+ ...reasoning,
1312
+ cacheReadTokens: prompt.cacheReadTokens,
1313
+ cacheWriteTokens: prompt.cacheWriteTokens,
1314
+ totalTokens: prompt.inputTokens + prompt.cacheReadTokens + prompt.cacheWriteTokens + outputTokens,
1315
+ }
1316
+ }
1317
+
1318
+ const inputTokens = Math.max(1, Math.ceil(estimateTextTokens(this.inputChars, 0)))
1247
1319
  return {
1248
- inputTokens: input,
1249
- outputTokens: Math.max(1, output.outputTokens),
1320
+ inputTokens,
1321
+ outputTokens,
1322
+ ...reasoning,
1250
1323
  cacheReadTokens: 0,
1251
1324
  cacheWriteTokens: 0,
1252
- totalTokens: input + Math.max(1, output.outputTokens),
1325
+ totalTokens: inputTokens + outputTokens,
1253
1326
  }
1254
1327
  }
1255
1328