@cesarus777/opencode-cgp 0.2.3 → 0.3.0

package/dist/rpc.js

@@ -1,174 +1,33 @@
 // @bun
-// src/rpc.ts
-import { Rpc } from "@opencode/plugin/rpc";
-var count = {
-  type: "integer",
-  minimum: 0,
-  maximum: Number.MAX_SAFE_INTEGER
-};
-var text = { type: "string", minLength: 1, maxLength: 512 };
-var enumeration = (...values) => ({ type: "string", enum: values });
-var object = (properties, required = Object.keys(properties)) => ({
-  type: "object",
-  properties,
-  required,
-  additionalProperties: false
-});
-var array = (items, maxItems = 128) => ({
-  type: "array",
-  items,
-  maxItems
-});
-var measurement = object({
-  tokens: count,
-  at: count,
-  model: text,
-  requestId: text,
-  provenance: enumeration("provider-normalized", "serialized-estimate"),
-  confidence: enumeration("reported", "approximate"),
-  scope: enumeration("completed-request", "prepared-request")
-}, ["tokens", "at", "model", "provenance", "confidence", "scope"]);
-var row = object({
-  sessionId: text,
-  revision: count,
-  observedAt: count,
-  parentId: text,
-  agent: text,
-  model: text,
-  measurement,
-  limits: object({ context: count, input: count, output: count }, [
-    "context",
-    "output"
-  ]),
-  capacityTokens: count,
-  outputReserveTokens: count,
-  peakTokens: count,
-  policy: object({
-    id: text,
-    configured: object({
-      type: enumeration("tokens", "ratio", "remaining"),
-      value: { type: "number", minimum: 0 }
-    }),
-    triggerTokens: { type: "number" },
-    comparison: enumeration(">=", ">"),
-    reason: enumeration("missing-usage", "model-changed", "invalid-usage", "stale-usage", "missing-model-budget", "incompatible-model-budget", "threshold-crossed", "below-threshold"),
-    crossed: { type: "boolean" }
-  }, ["id", "configured", "comparison", "reason", "crossed"]),
-  compaction: object({
-    phase: enumeration("idle", "requesting", "accepted", "running", "awaiting-measurement", "blocked", "uncertain"),
-    count,
-    armed: { type: "boolean" },
-    blockedReason: enumeration("session-removed", "compaction-failed", "reclaim-unverifiable", "insufficient-reclaim", "completion-event-timeout", "admission-outcome-unknown", "restart-needs-lifecycle-evidence"),
-    lastAttempt: count,
-    lastCompleted: count,
-    cooldownUntil: count
-  }, ["phase", "armed"]),
-  cumulative: object({
-    input: count,
-    output: count,
-    reasoning: count,
-    cache: object({ read: count, write: count })
-  }),
-  cumulativeScope: enumeration("session", "unknown"),
-  lastObservedActive: { type: "boolean" }
-}, [
-  "sessionId",
-  "revision",
-  "observedAt",
-  "policy",
-  "compaction",
-  "cumulativeScope",
-  "lastObservedActive"
-]);
-var batchFields = {
-  schemaVersion: { const: 1 },
-  epoch: text,
-  sequence: count,
-  generatedAt: count,
-  health: object({
-    enabled: { type: "boolean" },
-    mode: enumeration("observe", "enforce"),
-    enforcement: enumeration("observing", "available", "suspended", "disabled"),
-    reasons: array(enumeration("event-stream-gap", "persistence-unavailable", "capacity-exceeded", "model-metadata-unavailable"), 8),
-    staleMs: count,
-    maxSessions: count
-  }),
-  upserts: array(row),
-  removed: array(object({
-    sessionId: text,
-    revision: count,
-    reason: enumeration("deleted", "evicted")
-  }))
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
 };
-var readSchema = object({
-  schemaVersion: { const: 1 },
-  sessionIds: { ...array(text), uniqueItems: true }
-});
-var batchSchema = object(batchFields);
-var resultSchema = object({
-  ...batchFields,
-  unavailable: array(object({ sessionId: text, reason: enumeration("not-monitored") }))
-});
-var monitorRpc = Rpc.define({
-  id: "context-guard.monitor.v1",
-  methods: { read: { input: readSchema, output: resultSchema } },
-  events: { changed: { schema: batchSchema } }
-});
-var nonnegative = { type: "number", minimum: 0 };
-var performanceSchema = object({
-  observedSince: count,
-  at: count,
-  sessionCreatedAt: count,
-  sessionOutputTokens: count,
-  status: enumeration("waiting", "streaming", "idle", "unavailable"),
-  partial: { type: "boolean" },
-  liveTps: nonnegative,
-  averageModelTps: nonnegative,
-  averageSessionTps: nonnegative,
-  ttftMs: nonnegative,
-  latestRequestTps: nonnegative,
-  requestId: text,
-  requestAgent: text,
-  requestModel: text,
-  requestOutputTokens: count,
-  requestStartedAt: count,
-  firstOutputAt: count,
-  streamEndedAt: count,
-  estimatedOutputTokens: nonnegative,
-  modelOutputTokens: nonnegative,
-  modelDurationMs: nonnegative,
-  completedRequests: count,
-  tokenSource: enumeration("estimated", "reported", "unavailable")
-}, [
-  "sessionCreatedAt",
-  "observedSince",
-  "at",
-  "status",
-  "partial",
-  "estimatedOutputTokens",
-  "modelOutputTokens",
-  "modelDurationMs",
-  "completedRequests",
-  "tokenSource"
-]);
-var performanceRow = {
-  ...row,
-  properties: { ...row.properties, performance: performanceSchema }
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
-var performanceBatchSchema = object({
-  ...batchFields,
-  upserts: array(performanceRow)
-});
-var performanceResultSchema = object({
-  ...batchFields,
-  upserts: array(performanceRow),
-  unavailable: resultSchema.properties.unavailable ?? {}
-});
-var performanceRpc = Rpc.define({
-  id: "context-guard.monitor.v2",
-  methods: { read: { input: readSchema, output: performanceResultSchema } },
-  events: { changed: { schema: performanceBatchSchema } }
-});
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/rpc.ts
+import { Rpc } from "@opencode/plugin/rpc";
 function isPerformanceBatch(value) {
   return valid(value, performanceBatchSchema) && uniqueRows(value);
 }
@@ -178,84 +37,6 @@ function isPerformanceResult(value) {
 function isPerformanceSnapshot(value) {
   return valid(value, performanceSchema);
 }
-var chartPointSchema = object({
-  time: count,
-  agent: text,
-  model: text,
-  breakBefore: { type: "boolean" },
-  partial: { type: "boolean" },
-  liveTps: nonnegative,
-  averageModelTps: nonnegative,
-  averageSessionTps: nonnegative,
-  sessionOutputTokens: count
-}, ["time", "breakBefore", "partial"]);
-var chartRequestSchema = object({
-  time: count,
-  requestId: text,
-  started: count,
-  agent: text,
-  model: text,
-  ttftMs: nonnegative,
-  outputTokens: count,
-  durationMs: nonnegative,
-  tps: nonnegative,
-  partial: { type: "boolean" }
-}, ["time", "requestId", "started", "partial"]);
-var historyReadSchema = object({
-  schemaVersion: { const: 1 },
-  sessionId: text,
-  from: count,
-  to: count,
-  maxPoints: { type: "integer", minimum: 16, maximum: 500 }
-});
-var historyResultSchema = object({
-  schemaVersion: { const: 1 },
-  generatedAt: count,
-  enabled: { type: "boolean" },
-  truncated: { type: "boolean" },
-  metadata: object({
-    schema: { const: 1 },
-    retainedFrom: count,
-    retainedBytes: count,
-    skippedBytes: count,
-    malformedRecords: count,
-    completeness: enumeration("bounded-retention")
-  }, [
-    "schema",
-    "retainedBytes",
-    "skippedBytes",
-    "malformedRecords",
-    "completeness"
-  ]),
-  data: object({
-    schema: { const: 1 },
-    omittedSessions: count,
-    omittedGaps: count,
-    maxPoints: count,
-    gaps: array(object({ time: count, sessionId: text, reason: text }), 128),
-    series: array(object({
-      sessionId: text,
-      parentId: text,
-      agents: array(text, 1024),
-      models: array(text, 1024),
-      points: array(chartPointSchema, 500),
-      requests: array(chartRequestSchema, 500),
-      originalPoints: count
-    }, [
-      "sessionId",
-      "agents",
-      "models",
-      "points",
-      "requests",
-      "originalPoints"
-    ]), 1)
-  }, ["schema", "omittedSessions", "maxPoints", "gaps", "series"])
-});
-var historyRpc = Rpc.define({
-  id: "context-guard.history.v1",
-  methods: { read: { input: historyReadSchema, output: historyResultSchema } },
-  events: {}
-});
 function isHistoryRead(value) {
   return valid(value, historyReadSchema) && record(value) && typeof value.from === "number" && typeof value.to === "number" && value.from <= value.to && value.to - value.from <= 7 * 86400000;
 }
@@ -310,6 +91,254 @@ function uniqueRows(value) {
   const ids = [...value.upserts, ...value.removed].map((v) => record(v) ? v.sessionId : undefined);
   return ids.length <= 128 && new Set(ids).size === ids.length;
 }
+var count, text, enumeration = (...values) => ({ type: "string", enum: values }), object = (properties, required = Object.keys(properties)) => ({
+  type: "object",
+  properties,
+  required,
+  additionalProperties: false
+}), array = (items, maxItems = 128) => ({
+  type: "array",
+  items,
+  maxItems
+}), measurement, row, batchFields, readSchema, batchSchema, resultSchema, monitorRpc, nonnegative, performanceSchema, performanceRow, performanceBatchSchema, performanceResultSchema, performanceRpc, chartPointSchema, chartRequestSchema, historyReadSchema, historyResultSchema, historyRpc;
+var init_rpc = __esm(() => {
+  count = {
+    type: "integer",
+    minimum: 0,
+    maximum: Number.MAX_SAFE_INTEGER
+  };
+  text = { type: "string", minLength: 1, maxLength: 512 };
+  measurement = object({
+    tokens: count,
+    at: count,
+    model: text,
+    requestId: text,
+    provenance: enumeration("provider-normalized", "serialized-estimate"),
+    confidence: enumeration("reported", "approximate"),
+    scope: enumeration("completed-request", "prepared-request")
+  }, ["tokens", "at", "model", "provenance", "confidence", "scope"]);
+  row = object({
+    sessionId: text,
+    revision: count,
+    observedAt: count,
+    parentId: text,
+    agent: text,
+    model: text,
+    measurement,
+    limits: object({ context: count, input: count, output: count }, [
+      "context",
+      "output"
+    ]),
+    capacityTokens: count,
+    outputReserveTokens: count,
+    peakTokens: count,
+    policy: object({
+      id: text,
+      configured: object({
+        type: enumeration("tokens", "ratio", "remaining"),
+        value: { type: "number", minimum: 0 }
+      }),
+      triggerTokens: { type: "number" },
+      comparison: enumeration(">=", ">"),
+      reason: enumeration("missing-usage", "model-changed", "invalid-usage", "stale-usage", "missing-model-budget", "incompatible-model-budget", "threshold-crossed", "below-threshold"),
+      crossed: { type: "boolean" }
+    }, ["id", "configured", "comparison", "reason", "crossed"]),
+    compaction: object({
+      phase: enumeration("idle", "requesting", "accepted", "running", "awaiting-measurement", "blocked", "uncertain"),
+      count,
+      armed: { type: "boolean" },
+      blockedReason: enumeration("session-removed", "compaction-failed", "reclaim-unverifiable", "insufficient-reclaim", "completion-event-timeout", "admission-outcome-unknown", "restart-needs-lifecycle-evidence"),
+      lastAttempt: count,
+      lastCompleted: count,
+      cooldownUntil: count
+    }, ["phase", "armed"]),
+    cumulative: object({
+      input: count,
+      output: count,
+      reasoning: count,
+      cache: object({ read: count, write: count })
+    }),
+    cumulativeScope: enumeration("session", "unknown"),
+    lastObservedActive: { type: "boolean" }
+  }, [
+    "sessionId",
+    "revision",
+    "observedAt",
+    "policy",
+    "compaction",
+    "cumulativeScope",
+    "lastObservedActive"
+  ]);
+  batchFields = {
+    schemaVersion: { const: 1 },
+    epoch: text,
+    sequence: count,
+    generatedAt: count,
+    health: object({
+      enabled: { type: "boolean" },
+      mode: enumeration("observe", "enforce"),
+      enforcement: enumeration("observing", "available", "suspended", "disabled"),
+      reasons: array(enumeration("event-stream-gap", "persistence-unavailable", "capacity-exceeded", "model-metadata-unavailable"), 8),
+      staleMs: count,
+      maxSessions: count
+    }),
+    upserts: array(row),
+    removed: array(object({
+      sessionId: text,
+      revision: count,
+      reason: enumeration("deleted", "evicted")
+    }))
+  };
+  readSchema = object({
+    schemaVersion: { const: 1 },
+    sessionIds: { ...array(text), uniqueItems: true }
+  });
+  batchSchema = object(batchFields);
+  resultSchema = object({
+    ...batchFields,
+    unavailable: array(object({ sessionId: text, reason: enumeration("not-monitored") }))
+  });
+  monitorRpc = Rpc.define({
+    id: "context-guard.monitor.v1",
+    methods: { read: { input: readSchema, output: resultSchema } },
+    events: { changed: { schema: batchSchema } }
+  });
+  nonnegative = { type: "number", minimum: 0 };
+  performanceSchema = object({
+    observedSince: count,
+    at: count,
+    sessionCreatedAt: count,
+    sessionOutputTokens: count,
+    status: enumeration("waiting", "streaming", "idle", "unavailable"),
+    partial: { type: "boolean" },
+    liveTps: nonnegative,
+    averageModelTps: nonnegative,
+    averageSessionTps: nonnegative,
+    ttftMs: nonnegative,
+    latestRequestTps: nonnegative,
+    requestId: text,
+    requestAgent: text,
+    requestModel: text,
+    requestOutputTokens: count,
+    requestStartedAt: count,
+    firstOutputAt: count,
+    streamEndedAt: count,
+    estimatedOutputTokens: nonnegative,
+    modelOutputTokens: nonnegative,
+    modelDurationMs: nonnegative,
+    completedRequests: count,
+    tokenSource: enumeration("estimated", "reported", "unavailable")
+  }, [
+    "sessionCreatedAt",
+    "observedSince",
+    "at",
+    "status",
+    "partial",
+    "estimatedOutputTokens",
+    "modelOutputTokens",
+    "modelDurationMs",
+    "completedRequests",
+    "tokenSource"
+  ]);
+  performanceRow = {
+    ...row,
+    properties: { ...row.properties, performance: performanceSchema }
+  };
+  performanceBatchSchema = object({
+    ...batchFields,
+    upserts: array(performanceRow)
+  });
+  performanceResultSchema = object({
+    ...batchFields,
+    upserts: array(performanceRow),
+    unavailable: resultSchema.properties.unavailable ?? {}
+  });
+  performanceRpc = Rpc.define({
+    id: "context-guard.monitor.v2",
+    methods: { read: { input: readSchema, output: performanceResultSchema } },
+    events: { changed: { schema: performanceBatchSchema } }
+  });
+  chartPointSchema = object({
+    time: count,
+    agent: text,
+    model: text,
+    breakBefore: { type: "boolean" },
+    partial: { type: "boolean" },
+    liveTps: nonnegative,
+    averageModelTps: nonnegative,
+    averageSessionTps: nonnegative,
+    sessionOutputTokens: count
+  }, ["time", "breakBefore", "partial"]);
+  chartRequestSchema = object({
+    time: count,
+    requestId: text,
+    started: count,
+    agent: text,
+    model: text,
+    ttftMs: nonnegative,
+    outputTokens: count,
+    durationMs: nonnegative,
+    tps: nonnegative,
+    partial: { type: "boolean" }
+  }, ["time", "requestId", "started", "partial"]);
+  historyReadSchema = object({
+    schemaVersion: { const: 1 },
+    sessionId: text,
+    from: count,
+    to: count,
+    maxPoints: { type: "integer", minimum: 16, maximum: 500 }
+  });
+  historyResultSchema = object({
+    schemaVersion: { const: 1 },
+    generatedAt: count,
+    enabled: { type: "boolean" },
+    truncated: { type: "boolean" },
+    metadata: object({
+      schema: { const: 1 },
+      retainedFrom: count,
+      retainedBytes: count,
+      skippedBytes: count,
+      malformedRecords: count,
+      completeness: enumeration("bounded-retention")
+    }, [
+      "schema",
+      "retainedBytes",
+      "skippedBytes",
+      "malformedRecords",
+      "completeness"
+    ]),
+    data: object({
+      schema: { const: 1 },
+      omittedSessions: count,
+      omittedGaps: count,
+      maxPoints: count,
+      gaps: array(object({ time: count, sessionId: text, reason: text }), 128),
+      series: array(object({
+        sessionId: text,
+        parentId: text,
+        agents: array(text, 1024),
+        models: array(text, 1024),
+        points: array(chartPointSchema, 500),
+        requests: array(chartRequestSchema, 500),
+        originalPoints: count
+      }, [
+        "sessionId",
+        "agents",
+        "models",
+        "points",
+        "requests",
+        "originalPoints"
+      ]), 1)
+    }, ["schema", "omittedSessions", "maxPoints", "gaps", "series"])
+  });
+  historyRpc = Rpc.define({
+    id: "context-guard.history.v1",
+    methods: { read: { input: historyReadSchema, output: historyResultSchema } },
+    events: {}
+  });
+});
+init_rpc();
+
 export {
   resultSchema,
   readSchema,