@opengeni/contracts 3.1.0-canary.1 → 3.1.2

package/src/define-schema.ts

@@ -0,0 +1,10 @@
+/**
+ * Construct a schema eagerly, but give bundlers one removable boundary around
+ * the whole initializer (including nested schemas and chained builders).
+ * Annotate calls with @__PURE__ only when the factory has no effects beyond
+ * constructing its returned schema. This is not lazy validation: used schemas
+ * are created once, in the same module evaluation order as ordinary constants.
+ */
+export function defineSchema<Schema>(factory: () => Schema): Schema {
+  return factory();
+}

package/src/direct-model-provider.ts

@@ -0,0 +1,108 @@
+import { defineSchema } from "./define-schema";
+import { z } from "zod";
+
+export const DirectModelProvider = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["openai", "azure_openai"]),
+);
+export type DirectModelProvider = z.infer<typeof DirectModelProvider>;
+
+/** Pin customer credentials to official provider origins, never arbitrary URLs. */
+export const AzureOpenAIEndpoint = /* @__PURE__ */ defineSchema(() =>
+  z
+    .string()
+    .trim()
+    .url()
+    .superRefine((value, ctx) => {
+      let url: URL;
+      try {
+        url = new URL(value);
+      } catch {
+        // The preceding URL validator supplies the normal validation issue.
+        return;
+      }
+      if (
+        url.protocol !== "https:" ||
+        url.username ||
+        url.password ||
+        url.port ||
+        !/^[a-z0-9-]+\.openai\.azure\.com$/i.test(url.hostname) ||
+        !["", "/", "/openai/v1", "/openai/v1/"].includes(url.pathname) ||
+        url.search ||
+        url.hash
+      ) {
+        ctx.addIssue({
+          code: "custom",
+          message: "Enter your Azure OpenAI HTTPS resource endpoint",
+        });
+      }
+    })
+    .transform((value) => new URL(value).origin + "/openai/v1"),
+);
+
+export const DirectModelProviderMetadata = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      provider: DirectModelProvider,
+      model: z
+        .string()
+        .trim()
+        .min(1)
+        .max(128)
+        .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
+      endpoint: AzureOpenAIEndpoint.optional(),
+    })
+    .strict()
+    .superRefine((value, ctx) => {
+      if (value.provider === "azure_openai" && !value.endpoint) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["endpoint"],
+          message: "Azure OpenAI needs an endpoint",
+        });
+      }
+      if (value.provider === "openai" && value.endpoint) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["endpoint"],
+          message: "OpenAI uses its official API endpoint",
+        });
+      }
+    }),
+);
+export type DirectModelProviderMetadata = z.infer<typeof DirectModelProviderMetadata>;
+
+export function directModelConnectionSpec(connection: {
+  id: string;
+  version: number;
+  subjectId: string | null;
+  kind: string;
+  status: string;
+  providerDomain: string;
+  metadata: Record<string, unknown>;
+}) {
+  if (
+    connection.subjectId !== null ||
+    connection.kind !== "api_key" ||
+    connection.status !== "active"
+  )
+    return null;
+  const parsed = DirectModelProviderMetadata.safeParse(connection.metadata.directModelProvider);
+  if (!parsed.success || connection.metadata.credentialRole !== `direct_${parsed.data.provider}`)
+    return null;
+  const config = parsed.data;
+  const baseUrl = config.provider === "openai" ? "https://api.openai.com/v1" : config.endpoint!;
+  if (connection.providerDomain.toLowerCase() !== new URL(baseUrl).hostname) return null;
+  const providerId = `workspace-${config.provider === "openai" ? "openai" : "azure-openai"}-${connection.id}`;
+  return {
+    ...config,
+    baseUrl,
+    providerId,
+    modelId: `${providerId}/${connection.version}/${config.model}`,
+    connectionId: connection.id,
+    version: connection.version,
+  };
+}
+
+export function isDirectModelId(modelId: string): boolean {
+  return /^workspace-(?:openai|azure-openai)-[0-9a-f-]{36}\//.test(modelId);
+}

package/src/editable-artifact-committed-transaction.ts

@@ -8,6 +8,11 @@
  */
 
 import { COMMITTED_TRANSACTION_PROTOCOL_VERSION } from "./editable-artifact-versions";
+import {
+  SPREADSHEET_DEFAULT_ROW_HEIGHT,
+  SPREADSHEET_DEFAULT_COLUMN_WIDTH,
+  SPREADSHEET_MAX_DIMENSION_PIXELS,
+} from "./spreadsheet-artifact-commands";
 
 export { COMMITTED_TRANSACTION_PROTOCOL_VERSION } from "./editable-artifact-versions";
 export const MAX_COMMITTED_TRANSACTION_BYTES = 8 * 1024 * 1024;
@@ -281,6 +286,18 @@ class Reader {
       case 5:
         this.stableId("selective undo target");
         return totalCells;
+      case 6:
+      case 7: {
+        this.skipGeneration("dimension sheet generation");
+        this.u32("dimension index");
+        const pixels = this.u32("dimension pixels");
+        const defaultPixels =
+          tag === 6 ? SPREADSHEET_DEFAULT_ROW_HEIGHT : SPREADSHEET_DEFAULT_COLUMN_WIDTH;
+        if (pixels > SPREADSHEET_MAX_DIMENSION_PIXELS || pixels === defaultPixels) {
+          throw new TypeError("OGACO002 dimension pixels are noncanonical or outside bounds");
+        }
+        return totalCells;
+      }
       default:
         throw new TypeError(`invalid OGACO002 collaboration command tag: ${tag}`);
     }

package/src/editable-artifact-versions.ts

@@ -1,4 +1,10 @@
-/** Modality-specific durable semantic/schema versions. */
+/**
+ * Modality-specific durable semantic/schema versions.
+ * Spreadsheet dimensions are an additive current-schema extension: existing
+ * command/operation tags and dimension-free snapshot bytes stay unchanged.
+ * Direct snapshots and private projections advertise their explicit extension
+ * flags; old executables reject new tags/flags, never silently discard them.
+ */
 export const SPREADSHEET_ARTIFACT_MODEL_SCHEMA_VERSION = 2 as const;
 export const DOCUMENT_ARTIFACT_MODEL_SCHEMA_VERSION = 1 as const;
 export const PRESENTATION_ARTIFACT_MODEL_SCHEMA_VERSION = 1 as const;

package/src/event-preview.ts

@@ -15,6 +15,18 @@ import {
 
 export const SESSION_EVENT_PAYLOAD_MAX_BYTES = 64 * 1024;
 
+/**
+ * Durable ceiling for one `agent.toolCall.output` event. The event is the
+ * human/audit record of a tool result; model history keeps its own truncated
+ * copy separately. A tool can return far more than anyone ever sees (a shell
+ * command printing a 45 MB line, for example), and storing that inline made
+ * every later history read load it whole. The budget comfortably exceeds the
+ * model-facing tool-output truncation, so the timeline never shows less than
+ * the model saw.
+ */
+export const TOOL_CALL_OUTPUT_EVENT_MAX_BYTES = 256 * 1024;
+const TOOL_CALL_OUTPUT_EVENT_STRING_BYTES = 64 * 1024;
+
 const TARGET_PAYLOAD_BYTES = 60 * 1024;
 const DEFAULT_STRING_BYTES = 8 * 1024;
 const RETRY_STRING_BYTES = 1024;
@@ -90,6 +102,11 @@ export type SessionEventPayloadTruncation = {
 export type BoundSessionEventPayloadOptions = {
   surface?: SessionEventBoundarySurface;
   maxBytes?: number;
+  /**
+   * Per-string head+tail budget once the payload must be bounded. Defaults to
+   * the compact preview budget; larger budgets keep the byte target at maxBytes.
+   */
+  stringBytes?: number;
   /**
    * Separately trusted durable receipt. Producer payload fields never populate
    * this slot; invalid values fail closed to not_retained.
@@ -195,12 +212,23 @@ export function boundSessionEventPayload<T>(
 ): T {
   const maxBytes = Math.max(1024, Math.floor(options.maxBytes ?? SESSION_EVENT_PAYLOAD_MAX_BYTES));
   const surface = options.surface ?? "durable_audit";
+  const customStringBytes =
+    options.stringBytes === undefined
+      ? null
+      : Math.max(RETRY_STRING_BYTES, Math.floor(options.stringBytes));
+  const stringBytes = customStringBytes ?? DEFAULT_STRING_BYTES;
+  const retryStringBytes =
+    customStringBytes === null
+      ? RETRY_STRING_BYTES
+      : Math.max(RETRY_STRING_BYTES, Math.floor(customStringBytes / 8));
+  const targetBytes =
+    customStringBytes === null ? Math.min(maxBytes, TARGET_PAYLOAD_BYTES) : maxBytes;
   const fullEvidence =
     validateRetainedOutputEvidence(options.fullEvidence) ?? retainedOutputUnavailable();
   const originalMeasurement = measureJsonBytes(payload);
   const originalBytes = originalMeasurement.bytes;
 
-  let state = previewState(DEFAULT_STRING_BYTES, DEFAULT_ARRAY_ENTRIES, DEFAULT_OBJECT_FIELDS);
+  let state = previewState(stringBytes, DEFAULT_ARRAY_ENTRIES, DEFAULT_OBJECT_FIELDS);
   let preview = previewValue(payload, state, "$", 0);
   if (!state.changed && originalBytes !== null && originalBytes <= maxBytes) {
     return payload;
@@ -212,8 +240,8 @@ export function boundSessionEventPayload<T>(
     boundaryMetadata(surface, reason, originalBytes, state, fullEvidence),
   );
 
-  if (sessionEventJsonBytes(bounded) > Math.min(maxBytes, TARGET_PAYLOAD_BYTES)) {
-    state = previewState(RETRY_STRING_BYTES, RETRY_ARRAY_ENTRIES, RETRY_OBJECT_FIELDS);
+  if (sessionEventJsonBytes(bounded) > targetBytes) {
+    state = previewState(retryStringBytes, RETRY_ARRAY_ENTRIES, RETRY_OBJECT_FIELDS);
     preview = previewValue(payload, state, "$", 0);
     reason = payloadTruncationReason(originalMeasurement, state);
     bounded = attachTruncation(
@@ -243,6 +271,28 @@ export function boundSessionEventPayload<T>(
   return bounded as T;
 }
 
+/**
+ * Write-time bound for durable session events. Only tool-call output has an
+ * unbounded producer; it is kept intact up to TOOL_CALL_OUTPUT_EVENT_MAX_BYTES
+ * and otherwise stored as an explicit head+tail preview whose `truncation`
+ * records the original size. Every other event type is returned unchanged.
+ */
+export function boundSessionEventPayloadForWrite<T>(type: string, payload: T): T {
+  if (type !== "agent.toolCall.output") return payload;
+  let bytes: number | null;
+  try {
+    bytes = sessionEventJsonBytes(payload);
+  } catch {
+    bytes = null;
+  }
+  if (bytes !== null && bytes <= TOOL_CALL_OUTPUT_EVENT_MAX_BYTES) return payload;
+  return boundSessionEventPayload(payload, {
+    surface: "durable_audit",
+    maxBytes: TOOL_CALL_OUTPUT_EVENT_MAX_BYTES,
+    stringBytes: TOOL_CALL_OUTPUT_EVENT_STRING_BYTES,
+  });
+}
+
 function previewState(
   stringBytes: number,
   arrayEntries: number,