@opengeni/contracts 0.1.0

package/dist/index.js

@@ -0,0 +1,1295 @@
+// src/index.ts
+import { z } from "zod";
+var SessionStatus = z.enum([
+  "queued",
+  "running",
+  "idle",
+  "requires_action",
+  "failed",
+  "cancelled"
+]);
+var SandboxBackend = z.enum(["docker", "modal", "local", "none"]);
+var ReasoningEffort = z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]);
+var ErrorCode = z.enum([
+  "unauthenticated",
+  "forbidden",
+  "not_found",
+  "validation_failed",
+  "conflict",
+  "idempotency_conflict",
+  "limit_exceeded",
+  "provider_verification_failed",
+  "upstream_unavailable",
+  "internal_error"
+]);
+var ErrorEnvelope = z.object({
+  error: z.object({
+    code: ErrorCode,
+    message: z.string(),
+    requestId: z.string().optional(),
+    details: z.record(z.string(), z.unknown()).optional()
+  })
+});
+var PageInfo = z.object({
+  limit: z.number().int().positive(),
+  nextCursor: z.string().nullable(),
+  hasMore: z.boolean()
+});
+function paginated(item) {
+  return z.object({
+    data: z.array(item),
+    page: PageInfo
+  });
+}
+var Permission = z.enum([
+  "account:read",
+  "account:admin",
+  "members:manage",
+  "workspace:create",
+  "billing:read",
+  "billing:manage",
+  "workspace:read",
+  "workspace:admin",
+  "sessions:create",
+  "sessions:read",
+  "sessions:control",
+  "files:upload",
+  "files:read",
+  "documents:manage",
+  "documents:search",
+  "scheduled_tasks:manage",
+  "scheduled_tasks:run",
+  "github:manage",
+  "github:use",
+  "api_keys:manage",
+  "environments:manage",
+  "environments:use",
+  "goals:manage"
+]);
+var ProductAccessMode = z.enum(["local", "configured", "managed"]);
+var BillingMode = z.enum(["disabled", "stripe"]);
+var EntitlementsMode = z.enum(["none", "static", "managed"]);
+var UsageLimitsMode = z.enum(["none", "static", "managed"]);
+var AccountRole = z.enum(["owner", "admin", "member"]);
+var ManagedAccount = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  externalSource: z.string().nullable(),
+  externalId: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var Workspace = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  name: z.string(),
+  slug: z.string().nullable(),
+  externalSource: z.string().nullable(),
+  externalId: z.string().nullable(),
+  // Per-workspace agent persona template (white-label override). null means
+  // the deployment default (OPENGENI_AGENT_INSTRUCTIONS_TEMPLATE /
+  // DEFAULT_AGENT_INSTRUCTIONS) is used. The runtime always injects the
+  // non-bypassable CORE (goal-loop ownership + environment block), so an
+  // override restyles the persona without dropping that contract.
+  agentInstructions: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var AccountGrant = z.object({
+  accountId: z.string().uuid(),
+  subjectId: z.string().min(1),
+  subjectLabel: z.string().optional(),
+  role: AccountRole.optional(),
+  permissions: z.array(Permission),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var AccessGrant = z.object({
+  workspaceId: z.string().uuid(),
+  accountId: z.string().uuid(),
+  subjectId: z.string().min(1),
+  subjectLabel: z.string().optional(),
+  permissions: z.array(Permission),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var AccessContext = z.object({
+  mode: ProductAccessMode,
+  subjectId: z.string().min(1),
+  subjectLabel: z.string().optional(),
+  accountGrants: z.array(AccountGrant),
+  workspaceGrants: z.array(AccessGrant),
+  defaultAccountId: z.string().uuid().nullable(),
+  defaultWorkspaceId: z.string().uuid().nullable()
+});
+var DelegatedAccessTokenPayload = z.object({
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  subjectId: z.string().min(1),
+  subjectLabel: z.string().optional(),
+  permissions: z.array(Permission).min(1),
+  // Worker-asserted session scope for first-party MCP calls (HMAC-signed, not
+  // agent-controlled); enables session-scoped tools such as goal management.
+  sessionId: z.string().uuid().optional(),
+  exp: z.number().int().positive()
+});
+async function signDelegatedAccessToken(secret, payload) {
+  const encodedPayload = base64UrlEncode(JSON.stringify(DelegatedAccessTokenPayload.parse(payload)));
+  const signature = await hmacSha256Base64Url(secret, encodedPayload);
+  return `ogd_${encodedPayload}.${signature}`;
+}
+async function verifyDelegatedAccessToken(secret, token, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  if (!token.startsWith("ogd_")) {
+    return null;
+  }
+  const withoutPrefix = token.slice("ogd_".length);
+  const dot = withoutPrefix.lastIndexOf(".");
+  if (dot <= 0) {
+    return null;
+  }
+  const encodedPayload = withoutPrefix.slice(0, dot);
+  const signature = withoutPrefix.slice(dot + 1);
+  const expected = await hmacSha256Base64Url(secret, encodedPayload);
+  if (!constantTimeEqual(signature, expected)) {
+    return null;
+  }
+  const payload = DelegatedAccessTokenPayload.safeParse(JSON.parse(base64UrlDecode(encodedPayload)));
+  if (!payload.success || payload.data.exp < nowSeconds) {
+    return null;
+  }
+  return payload.data;
+}
+var CreateWorkspaceRequest = z.object({
+  accountId: z.string().uuid().optional(),
+  name: z.string().min(1),
+  slug: z.string().min(1).optional(),
+  externalSource: z.string().min(1).optional(),
+  externalId: z.string().min(1).optional(),
+  // White-label persona override for this workspace's agent. null/omitted uses
+  // the deployment default template.
+  agentInstructions: z.string().min(1).nullable().optional()
+});
+var UpdateWorkspaceRequest = z.object({
+  name: z.string().min(1).optional(),
+  slug: z.string().min(1).nullable().optional(),
+  // White-label persona override. Pass null to clear it back to the deployment
+  // default; omit to leave it unchanged.
+  agentInstructions: z.string().min(1).nullable().optional()
+});
+var ApiKey = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid().nullable(),
+  name: z.string(),
+  prefix: z.string(),
+  permissions: z.array(Permission),
+  expiresAt: z.string().nullable(),
+  revokedAt: z.string().nullable(),
+  lastUsedAt: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var CreateApiKeyRequest = z.object({
+  name: z.string().min(1),
+  workspaceId: z.string().uuid().optional(),
+  permissions: z.array(Permission).min(1),
+  expiresAt: z.string().datetime({ offset: true }).optional()
+});
+var CreateApiKeyResponse = z.object({
+  apiKey: ApiKey,
+  token: z.string().min(1)
+});
+var UsageEventType = z.enum([
+  "agent_run.created",
+  "agent_run.completed",
+  "model.tokens",
+  "model.cost",
+  "file.uploaded",
+  "file.deleted",
+  "document.indexed",
+  "scheduled_task.fired",
+  "api_key.request"
+]);
+var UsageEvent = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  accountId: z.string().uuid(),
+  subjectId: z.string().nullable(),
+  eventType: UsageEventType,
+  quantity: z.number(),
+  unit: z.string(),
+  sourceResourceType: z.string().nullable(),
+  sourceResourceId: z.string().nullable(),
+  idempotencyKey: z.string(),
+  occurredAt: z.string(),
+  recordedAt: z.string(),
+  exportedToBillingAt: z.string().nullable(),
+  billingProviderEventId: z.string().nullable()
+});
+var LimitAction = z.enum([
+  "agent_run:create",
+  "tokens:consume",
+  "file:upload",
+  "document:index",
+  "schedule:create",
+  "workspace:create",
+  "api_key:create"
+]);
+var StaticUsageLimits = z.object({
+  maxWorkspacesPerAccount: z.number().int().positive().optional(),
+  maxApiKeysPerWorkspace: z.number().int().positive().optional(),
+  maxSchedulesPerWorkspace: z.number().int().positive().optional(),
+  maxFileUploadBytes: z.number().int().positive().optional(),
+  maxMonthlyAgentRunsPerWorkspace: z.number().int().positive().optional(),
+  maxMonthlyTokensPerWorkspace: z.number().int().positive().optional(),
+  maxMonthlyCostMicrosPerAccount: z.number().int().positive().optional(),
+  maxDocumentIndexedChunksPerWorkspace: z.number().int().positive().optional()
+});
+var EntitlementValue = z.union([z.boolean(), z.string(), z.number(), z.array(z.string())]);
+var Entitlements = z.record(z.string().min(1), EntitlementValue);
+var LimitDecision = z.discriminatedUnion("allowed", [
+  z.object({ allowed: z.literal(true) }),
+  z.object({ allowed: z.literal(false), code: z.string(), message: z.string() })
+]);
+var BillingBalance = z.object({
+  accountId: z.string().uuid(),
+  balanceMicros: z.number().int(),
+  currency: z.literal("usd"),
+  updatedAt: z.string()
+});
+var CreateCheckoutRequest = z.object({
+  accountId: z.string().uuid().optional(),
+  amountUsd: z.number().min(5).max(1e4).refine(
+    (value) => Number.isFinite(value) && Math.abs(value - Math.round(value * 100) / 100) < 1e-9,
+    { message: "amountUsd must use cent precision" }
+  ),
+  successUrl: z.string().url().optional(),
+  cancelUrl: z.string().url().optional()
+});
+var CreateCheckoutResponse = z.object({
+  checkoutSessionId: z.string(),
+  url: z.string().url()
+});
+var RepositoryResourceRef = z.object({
+  kind: z.literal("repository"),
+  uri: z.string().min(1),
+  ref: z.string().min(1),
+  mountPath: z.string().min(1).optional(),
+  subpath: z.string().min(1).optional(),
+  githubInstallationId: z.number().int().positive().optional(),
+  githubRepositoryId: z.number().int().positive().optional()
+});
+var FileResourceRef = z.object({
+  kind: z.literal("file"),
+  fileId: z.string().uuid(),
+  mountPath: z.string().min(1).optional()
+});
+var ResourceRef = z.discriminatedUnion("kind", [RepositoryResourceRef, FileResourceRef]);
+var FileStatus = z.enum(["pending_upload", "ready", "failed", "expired", "deleted"]);
+var FileUploadStatus = z.enum(["pending", "completed", "expired", "failed"]);
+var FileAsset = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  status: FileStatus,
+  filename: z.string(),
+  safeFilename: z.string(),
+  contentType: z.string(),
+  sizeBytes: z.number().int().nonnegative(),
+  sha256: z.string().nullable(),
+  bucket: z.string(),
+  objectKey: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var CreateFileUploadRequest = z.object({
+  filename: z.string().min(1),
+  contentType: z.string().min(1),
+  sizeBytes: z.number().int().positive(),
+  sha256: z.string().min(1).optional()
+});
+var CreateFileUploadResponse = z.object({
+  fileId: z.string().uuid(),
+  uploadId: z.string().uuid(),
+  putUrl: z.string().url(),
+  requiredHeaders: z.record(z.string(), z.string()),
+  expiresAt: z.string(),
+  maxSizeBytes: z.number().int().positive()
+});
+var CompleteFileUploadResponse = z.object({
+  file: FileAsset
+});
+var FileDownloadUrlResponse = z.object({
+  url: z.string().url(),
+  expiresAt: z.string()
+});
+var DocumentStatus = z.enum(["queued", "indexing", "ready", "failed"]);
+var DocumentBase = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  name: z.string(),
+  description: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var Document = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  baseId: z.string().uuid(),
+  fileId: z.string().uuid(),
+  status: DocumentStatus,
+  title: z.string(),
+  parser: z.string(),
+  chunkCount: z.number().int().nonnegative(),
+  error: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var DocumentSearchResult = z.object({
+  chunkId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  documentId: z.string().uuid(),
+  baseId: z.string().uuid(),
+  fileId: z.string().uuid(),
+  title: z.string(),
+  text: z.string(),
+  score: z.number(),
+  chunkIndex: z.number().int().nonnegative(),
+  metadata: z.record(z.string(), z.unknown())
+});
+var CreateDocumentBaseRequest = z.object({
+  name: z.string().min(1),
+  description: z.string().optional()
+});
+var AddDocumentRequest = z.object({
+  fileId: z.string().uuid()
+});
+var DocumentSearchRequest = z.object({
+  query: z.string().min(1),
+  limit: z.number().int().positive().max(20).default(5)
+});
+var ToolRef = z.object({
+  kind: z.literal("mcp"),
+  id: z.string().min(1)
+});
+var ResourceRefConflictError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ResourceRefConflictError";
+  }
+};
+function mergeToolRefs(existing, additions) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const tool of [...existing, ...additions]) {
+    const key = `${tool.kind}:${tool.id}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(tool);
+  }
+  return out;
+}
+function mergeResourceRefs(existing, additions, options = {}) {
+  const out = [...existing];
+  const mountPaths = new Map(existing.flatMap((resource) => resource.mountPath ? [[resource.mountPath, stableJson(resource)]] : []));
+  const identities = new Map(existing.map((resource) => [resourceIdentityKey(resource), stableJson(resource)]));
+  const exact = new Set(existing.map(stableJson));
+  for (const resource of additions) {
+    const serialized = stableJson(resource);
+    if (exact.has(serialized)) {
+      continue;
+    }
+    if (options.rejectConflicts) {
+      const existingAtMount = resource.mountPath ? mountPaths.get(resource.mountPath) : void 0;
+      if (existingAtMount && existingAtMount !== serialized) {
+        throw new ResourceRefConflictError(`resource mount path is already attached: ${resource.mountPath}`);
+      }
+      const identity = resourceIdentityKey(resource);
+      const existingIdentity = identities.get(identity);
+      if (existingIdentity && existingIdentity !== serialized) {
+        throw new ResourceRefConflictError(`resource is already attached with different settings: ${identity}`);
+      }
+    }
+    out.push(resource);
+    exact.add(serialized);
+    identities.set(resourceIdentityKey(resource), serialized);
+    if (resource.mountPath) {
+      mountPaths.set(resource.mountPath, serialized);
+    }
+  }
+  return out;
+}
+function reasoningEffortForMetadata(metadata, fallback) {
+  const value = metadata.reasoningEffort;
+  return value === "none" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" ? value : fallback;
+}
+function stableJson(value) {
+  return JSON.stringify(sortJson(value));
+}
+function resourceIdentityKey(resource) {
+  if (resource.kind === "file") {
+    return `file:${resource.fileId}`;
+  }
+  return `repository:${resource.uri}`;
+}
+function sortJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, nested]) => [key, sortJson(nested)]));
+  }
+  return value;
+}
+var SessionTurnStatus = z.enum(["queued", "running", "requires_action", "completed", "failed", "cancelled"]);
+var SessionTurnSource = z.enum(["user", "scheduled_task", "api", "goal"]);
+var SessionGoalStatus = z.enum(["active", "paused", "completed"]);
+var SessionGoalCreatedBy = z.enum(["api", "agent", "scheduled_task"]);
+var SessionGoalPausedReason = z.enum([
+  "agent",
+  "user_interrupt",
+  "api",
+  "no_progress",
+  "max_auto_continuations",
+  "limits"
+]);
+var SessionGoal = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  sessionId: z.string().uuid(),
+  status: SessionGoalStatus,
+  text: z.string(),
+  successCriteria: z.string().nullable(),
+  evidence: z.string().nullable(),
+  rationale: z.string().nullable(),
+  pausedReason: z.string().nullable(),
+  createdBy: SessionGoalCreatedBy,
+  version: z.number().int().positive(),
+  autoContinuations: z.number().int().nonnegative(),
+  noProgressStreak: z.number().int().nonnegative(),
+  maxAutoContinuations: z.number().int().positive().nullable(),
+  metadata: z.record(z.string(), z.unknown()),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var GoalSpec = z.object({
+  text: z.string().min(1),
+  successCriteria: z.string().min(1).optional(),
+  maxAutoContinuations: z.number().int().positive().optional()
+});
+var UpdateSessionGoalRequest = z.object({
+  status: z.enum(["paused", "active"]),
+  rationale: z.string().min(1).optional()
+});
+var ClearSessionContextRequest = z.object({
+  confirm: z.literal(true)
+});
+var CLEARED_RUN_STATE_MARKER = "$opengeniCleared";
+var CLEARED_RUN_STATE_BLOB = JSON.stringify({ [CLEARED_RUN_STATE_MARKER]: true });
+function isClearedRunStateBlob(serialized) {
+  if (!serialized) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(serialized);
+    return typeof parsed === "object" && parsed !== null && parsed[CLEARED_RUN_STATE_MARKER] === true;
+  } catch {
+    return false;
+  }
+}
+var CompactSessionContextRequest = z.object({}).strict();
+var CompactSessionContextResult = z.object({
+  // queued: a client-side (Azure) compaction will run before the next turn.
+  // noop:   nothing to do (server-managed provider, mode off, or no history).
+  status: z.enum(["queued", "noop"]),
+  message: z.string()
+});
+var SessionTurn = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  sessionId: z.string().uuid(),
+  triggerEventId: z.string().uuid(),
+  temporalWorkflowId: z.string(),
+  status: SessionTurnStatus,
+  source: SessionTurnSource,
+  position: z.number().int().positive(),
+  prompt: z.string().min(1),
+  resources: z.array(ResourceRef),
+  tools: z.array(ToolRef),
+  model: z.string().min(1),
+  reasoningEffort: ReasoningEffort,
+  sandboxBackend: SandboxBackend,
+  metadata: z.record(z.string(), z.unknown()),
+  startedAt: z.string().nullable(),
+  finishedAt: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var UpdateSessionTurnRequest = z.object({
+  prompt: z.string().min(1).optional(),
+  resources: z.array(ResourceRef).optional(),
+  tools: z.array(ToolRef).optional(),
+  model: z.string().min(1).optional(),
+  reasoningEffort: ReasoningEffort.optional(),
+  sandboxBackend: SandboxBackend.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var ReorderSessionTurnsRequest = z.object({
+  turnIds: z.array(z.string().uuid()).min(1)
+});
+var WorkspaceEnvironmentVariableName = z.string().regex(/^[A-Z][A-Z0-9_]*$/).max(128);
+var WorkspaceEnvironmentVariableMetadata = z.object({
+  name: WorkspaceEnvironmentVariableName,
+  version: z.number().int().positive(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var WorkspaceEnvironment = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  name: z.string(),
+  description: z.string().nullable(),
+  variables: z.array(WorkspaceEnvironmentVariableMetadata),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var CreateWorkspaceEnvironmentRequest = z.object({
+  name: z.string().min(1).max(120),
+  description: z.string().max(2e3).optional(),
+  variables: z.array(z.object({
+    name: WorkspaceEnvironmentVariableName,
+    value: z.string().min(1).max(32768)
+  })).default([])
+});
+var UpdateWorkspaceEnvironmentRequest = z.object({
+  name: z.string().min(1).max(120).optional(),
+  description: z.string().max(2e3).nullable().optional()
+});
+var SetWorkspaceEnvironmentVariableRequest = z.object({
+  value: z.string().min(1).max(32768)
+});
+var ScheduledTaskStatus = z.enum(["active", "paused"]);
+var ScheduledTaskRunStatus = z.enum(["queued", "dispatched", "failed"]);
+var ScheduledTaskRunMode = z.enum(["new_session_per_run", "reusable_session"]);
+var ScheduledTaskOverlapPolicy = z.enum(["allow_concurrent", "skip", "buffer_one"]);
+var ScheduledTaskTriggerType = z.enum(["scheduled", "manual"]);
+var ScheduledTaskScheduleSpec = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("once"),
+    runAt: z.string().datetime({ offset: true }),
+    timeZone: z.string().min(1).default("UTC")
+  }),
+  z.object({
+    type: z.literal("interval"),
+    everySeconds: z.number().int().positive(),
+    startAt: z.string().datetime({ offset: true }).optional(),
+    endAt: z.string().datetime({ offset: true }).optional()
+  }),
+  z.object({
+    type: z.literal("calendar"),
+    timeZone: z.string().min(1).default("UTC"),
+    hour: z.number().int().min(0).max(23),
+    minute: z.number().int().min(0).max(59),
+    daysOfWeek: z.array(z.enum(["SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY"])).min(1).optional()
+  })
+]);
+var ScheduledTaskAgentConfig = z.object({
+  prompt: z.string().min(1),
+  resources: z.array(ResourceRef).default([]),
+  tools: z.array(ToolRef).default([]),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  model: z.string().min(1).optional(),
+  reasoningEffort: ReasoningEffort.optional(),
+  sandboxBackend: SandboxBackend.optional(),
+  goal: GoalSpec.optional()
+});
+var ScheduledTask = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  name: z.string(),
+  status: ScheduledTaskStatus,
+  schedule: ScheduledTaskScheduleSpec,
+  temporalScheduleId: z.string(),
+  runMode: ScheduledTaskRunMode,
+  overlapPolicy: ScheduledTaskOverlapPolicy,
+  agentConfig: ScheduledTaskAgentConfig,
+  reusableSessionId: z.string().uuid().nullable(),
+  environmentId: z.string().uuid().nullable(),
+  metadata: z.record(z.string(), z.unknown()),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var ScheduledTaskRun = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  taskId: z.string().uuid(),
+  status: ScheduledTaskRunStatus,
+  triggerType: ScheduledTaskTriggerType,
+  scheduledAt: z.string().nullable(),
+  firedAt: z.string(),
+  sessionId: z.string().uuid().nullable(),
+  triggerEventId: z.string().uuid().nullable(),
+  error: z.string().nullable(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var CreateScheduledTaskRequest = z.object({
+  name: z.string().min(1),
+  schedule: ScheduledTaskScheduleSpec,
+  runMode: ScheduledTaskRunMode.default("new_session_per_run"),
+  overlapPolicy: ScheduledTaskOverlapPolicy.default("allow_concurrent"),
+  agentConfig: ScheduledTaskAgentConfig,
+  status: ScheduledTaskStatus.default("active"),
+  environmentId: z.string().uuid().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).default({})
+});
+var UpdateScheduledTaskRequest = z.object({
+  name: z.string().min(1).optional(),
+  schedule: ScheduledTaskScheduleSpec.optional(),
+  runMode: ScheduledTaskRunMode.optional(),
+  overlapPolicy: ScheduledTaskOverlapPolicy.optional(),
+  agentConfig: ScheduledTaskAgentConfig.optional(),
+  status: ScheduledTaskStatus.optional(),
+  environmentId: z.string().uuid().nullable().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var TriggerScheduledTaskRequest = z.object({
+  triggerId: z.string().min(1).max(128).optional()
+});
+var CapabilityPackConnectorAuthModel = z.enum([
+  "oauth2_authorization_code_pkce",
+  "oauth2_authorization_code",
+  "api_key",
+  "credential_ref"
+]);
+var CapabilityPackConnector = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  category: z.string().min(1),
+  authModel: CapabilityPackConnectorAuthModel,
+  providers: z.array(z.string().min(1)).default([]),
+  scopes: z.array(z.string().min(1)).default([]),
+  required: z.boolean().default(false),
+  metadata: z.record(z.string(), z.unknown()).default({})
+});
+var CapabilityPackKnowledge = z.object({
+  type: z.literal("document_base"),
+  id: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().nullable().default(null),
+  required: z.boolean().default(false)
+});
+var CapabilityPackScheduledTaskTemplate = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().min(1),
+  defaultSchedule: ScheduledTaskScheduleSpec,
+  defaultRunMode: ScheduledTaskRunMode.default("new_session_per_run"),
+  defaultOverlapPolicy: ScheduledTaskOverlapPolicy.default("skip"),
+  // Optional default agent prompt so registered pack manifests can ship fully
+  // instantiable templates; built-in packs may instead build prompts in code.
+  prompt: z.string().min(1).optional()
+});
+var CapabilityPackSkillFile = z.object({
+  path: z.string().min(1).max(512).refine(isSafePackSkillRelativePath, {
+    message: "skill file path must be a safe relative POSIX path without '..' segments"
+  }),
+  content: z.string().max(256 * 1024)
+});
+var CapabilityPackSkill = z.object({
+  name: z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, {
+    message: "skill name must be a single path segment of letters, digits, '.', '_' or '-'"
+  }),
+  description: z.string().min(1).max(2048).optional(),
+  files: z.array(CapabilityPackSkillFile).min(1).max(64)
+}).superRefine((skill, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  skill.files.forEach((file, index) => {
+    if (seen.has(file.path)) {
+      ctx.addIssue({ code: "custom", message: `duplicate skill file path: ${file.path}`, path: ["files", index, "path"] });
+    }
+    seen.add(file.path);
+  });
+  if (!skill.files.some((file) => file.path === "SKILL.md")) {
+    ctx.addIssue({ code: "custom", message: "skill must include a top-level SKILL.md file", path: ["files"] });
+  }
+});
+function isSafePackSkillRelativePath(path) {
+  if (path.startsWith("/") || path.includes("\\")) {
+    return false;
+  }
+  return path.split("/").every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+var CapabilityPack = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string().min(1),
+  role: z.string().min(1),
+  category: z.string().min(1),
+  version: z.string().min(1),
+  // Container image ref (digest-pinned recommended) the pack's sessions run
+  // in. At most one enabled pack per workspace may declare one; with none,
+  // sessions use the deployment-wide image settings.
+  sandboxImage: z.string().trim().min(1).max(512).optional(),
+  // Skills delivered into the sandbox skill index when the pack is enabled.
+  skills: z.array(CapabilityPackSkill).max(32).superRefine((skills, ctx) => {
+    const seen = /* @__PURE__ */ new Set();
+    skills.forEach((skill, index) => {
+      const key = skill.name.toLowerCase();
+      if (seen.has(key)) {
+        ctx.addIssue({ code: "custom", message: `duplicate pack skill name: ${skill.name}`, path: [index, "name"] });
+      }
+      seen.add(key);
+    });
+  }).default([]),
+  tools: z.array(ToolRef).default([]),
+  connectors: z.array(CapabilityPackConnector).default([]),
+  knowledge: z.array(CapabilityPackKnowledge).default([]),
+  scheduledTaskTemplates: z.array(CapabilityPackScheduledTaskTemplate).default([]),
+  environment: z.object({
+    description: z.string().min(1),
+    requiredVariables: z.array(WorkspaceEnvironmentVariableName).default([]),
+    required: z.boolean().default(false)
+  }).optional(),
+  metadata: z.record(z.string(), z.unknown()).default({})
+});
+var RegisterCapabilityPackRequest = CapabilityPack;
+var WorkspaceRegisteredPack = z.object({
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  pack: CapabilityPack,
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var PackInstallationStatus = z.enum(["active", "disabled"]);
+var PackInstallation = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  packId: z.string().min(1),
+  status: PackInstallationStatus,
+  metadata: z.record(z.string(), z.unknown()),
+  enabledAt: z.string(),
+  updatedAt: z.string()
+});
+var EnablePackRequest = z.object({
+  environmentId: z.string().uuid().optional(),
+  metadata: z.record(z.string(), z.unknown()).default({})
+});
+var SocialProvider = z.enum([
+  "x",
+  "linkedin",
+  "instagram",
+  "facebook",
+  "tiktok",
+  "youtube",
+  "custom"
+]);
+var SocialConnectionStatus = z.enum(["connected", "needs_reauth", "disabled"]);
+var SocialConnection = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  provider: SocialProvider,
+  accountHandle: z.string().min(1),
+  accountName: z.string().nullable(),
+  externalAccountId: z.string().nullable(),
+  status: SocialConnectionStatus,
+  scopes: z.array(z.string()),
+  credentialRef: z.string().nullable(),
+  tokenMetadata: z.record(z.string(), z.unknown()),
+  metadata: z.record(z.string(), z.unknown()),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var CreateSocialConnectionRequest = z.object({
+  provider: SocialProvider,
+  accountHandle: z.string().min(1),
+  accountName: z.string().min(1).optional(),
+  externalAccountId: z.string().min(1).optional(),
+  status: SocialConnectionStatus.default("connected"),
+  scopes: z.array(z.string().min(1)).default([]),
+  credentialRef: z.string().min(1).optional(),
+  tokenMetadata: z.record(z.string(), z.unknown()).default({}),
+  metadata: z.record(z.string(), z.unknown()).default({})
+});
+var SocialPost = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  connectionId: z.string().uuid(),
+  provider: SocialProvider,
+  externalPostId: z.string().nullable(),
+  url: z.string().url().nullable(),
+  authorHandle: z.string().nullable(),
+  text: z.string(),
+  publishedAt: z.string(),
+  metrics: z.record(z.string(), z.number()),
+  raw: z.record(z.string(), z.unknown()),
+  createdAt: z.string()
+});
+var CreateSocialPostRequest = z.object({
+  connectionId: z.string().uuid(),
+  externalPostId: z.string().min(1).optional(),
+  url: z.string().url().optional(),
+  authorHandle: z.string().min(1).optional(),
+  text: z.string().min(1),
+  publishedAt: z.string().datetime({ offset: true }),
+  metrics: z.record(z.string(), z.number()).default({}),
+  raw: z.record(z.string(), z.unknown()).default({})
+});
+var MarketingDailyAnalysisTaskRequest = z.object({
+  name: z.string().min(1).optional(),
+  connectionIds: z.array(z.string().uuid()).default([]),
+  documentBaseIds: z.array(z.string().uuid()).default([]),
+  timeZone: z.string().min(1).default("UTC"),
+  hour: z.number().int().min(0).max(23).default(9),
+  minute: z.number().int().min(0).max(59).default(0),
+  promptInstructions: z.string().min(1).optional(),
+  status: ScheduledTaskStatus.default("active"),
+  runMode: ScheduledTaskRunMode.default("new_session_per_run"),
+  overlapPolicy: ScheduledTaskOverlapPolicy.default("skip")
+});
+var CapabilityKind = z.enum(["pack", "mcp", "api", "skill", "plugin"]);
+var CapabilitySource = z.enum(["built_in", "configured", "public_registry", "manual"]);
+var CapabilityInstallationStatus = z.enum(["active", "disabled"]);
+var CapabilityRuntime = z.object({
+  available: z.boolean().default(false),
+  mcpServerId: z.string().min(1).optional(),
+  transport: z.string().min(1).optional(),
+  notes: z.string().nullable().default(null)
+});
+var CapabilityCatalogItem = z.object({
+  id: z.string().min(1),
+  accountId: z.string().uuid().optional(),
+  workspaceId: z.string().uuid().optional(),
+  kind: CapabilityKind,
+  source: CapabilitySource,
+  name: z.string().min(1),
+  description: z.string().nullable().default(null),
+  category: z.string().min(1).default("custom"),
+  tags: z.array(z.string().min(1)).default([]),
+  homepageUrl: z.string().url().nullable().default(null),
+  endpointUrl: z.string().url().nullable().default(null),
+  installUrl: z.string().url().nullable().default(null),
+  authModel: z.string().min(1).nullable().default(null),
+  tools: z.array(ToolRef).default([]),
+  runtime: CapabilityRuntime.default({ available: false, notes: null }),
+  enabled: z.boolean().default(false),
+  enabledReason: z.string().nullable().default(null),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+var CapabilityInstallation = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  capabilityId: z.string().min(1),
+  kind: CapabilityKind,
+  status: CapabilityInstallationStatus,
+  config: z.record(z.string(), z.unknown()),
+  metadata: z.record(z.string(), z.unknown()),
+  enabledAt: z.string(),
+  updatedAt: z.string()
+});
+var CreateCapabilityCatalogItemRequest = z.object({
+  id: z.string().min(1).optional(),
+  kind: CapabilityKind.exclude(["pack"]),
+  source: CapabilitySource.default("manual"),
+  name: z.string().min(1),
+  description: z.string().min(1).optional(),
+  category: z.string().min(1).default("custom"),
+  tags: z.array(z.string().min(1)).default([]),
+  homepageUrl: z.string().url().optional(),
+  endpointUrl: z.string().url().optional(),
+  installUrl: z.string().url().optional(),
+  authModel: z.string().min(1).optional(),
+  metadata: z.record(z.string(), z.unknown()).default({})
+});
+var EnableCapabilityRequest = z.object({
+  config: z.record(z.string(), z.unknown()).default({}),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  /**
+   * Credential headers for remote MCP capabilities (for example an
+   * Authorization bearer token). Values are encrypted at rest with the
+   * workspace-environments key, injected only into the runtime MCP client,
+   * and never returned by the API — responses expose header names only.
+   */
+  headers: z.record(z.string(), z.string()).default({}),
+  /**
+   * Initial environment attachment for kind=pack capabilities. Mirrors the
+   * dedicated POST /packs/:id/enable body: required to enable an
+   * environment.required pack through the unified capability-enable path,
+   * optional otherwise. Ignored by non-pack capabilities.
+   */
+  environmentId: z.string().uuid().optional()
+});
+var CapabilityCatalogResponse = z.object({
+  items: z.array(CapabilityCatalogItem),
+  installations: z.array(CapabilityInstallation)
+});
+var DiscoverMcpCapabilitiesResponse = z.object({
+  items: z.array(CapabilityCatalogItem),
+  source: z.literal("official_mcp_registry"),
+  sourceUrl: z.string().url()
+});
+var Session = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  accountId: z.string().uuid(),
+  status: SessionStatus,
+  initialMessage: z.string(),
+  resources: z.array(ResourceRef),
+  tools: z.array(ToolRef),
+  metadata: z.record(z.string(), z.unknown()),
+  model: z.string(),
+  sandboxBackend: SandboxBackend,
+  environmentId: z.string().uuid().nullable(),
+  // Non-default first-party MCP token permissions (manager-style sessions);
+  // null means the fixed worker default set.
+  firstPartyMcpPermissions: z.array(Permission).nullable(),
+  // The manager session that spawned this one via session_create (set only
+  // when the creating grant carried a worker-signed sessionId claim); null for
+  // direct API creates and scheduled-task runs. When set, this session's
+  // terminal-for-now transitions wake the parent.
+  parentSessionId: z.string().uuid().nullable(),
+  // Workspace-scoped CREATE idempotency key the session was created under (the
+  // dedup target collapsing double-submit/retry races to one session); null
+  // when the create carried no key.
+  createIdempotencyKey: z.string().nullable(),
+  temporalWorkflowId: z.string().nullable(),
+  activeTurnId: z.string().uuid().nullable(),
+  // Actual input tokens of the last model call of the most recent turn; the
+  // pre-turn client-side context-compaction trigger reads it as its budget
+  // signal. Null until a turn with usage has completed.
+  lastInputTokens: z.number().int().nonnegative().nullable(),
+  lastSequence: z.number().int().nonnegative(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var SessionEventType = z.enum([
+  "session.created",
+  "session.status.changed",
+  "session.requiresAction",
+  "session.context.compacted",
+  "session.context.cleared",
+  "user.message",
+  "user.interrupt",
+  "user.approvalDecision",
+  "turn.queued",
+  "turn.updated",
+  "turn.started",
+  "turn.completed",
+  "turn.failed",
+  "turn.cancelled",
+  "turn.preempted",
+  "agent.message.delta",
+  "agent.message.completed",
+  "agent.reasoning.delta",
+  "agent.toolCall.created",
+  "agent.toolCall.output",
+  "agent.updated",
+  "sandbox.operation.started",
+  "sandbox.operation.completed",
+  "sandbox.operation.failed",
+  "sandbox.command.output.delta",
+  "artifact.created",
+  "goal.set",
+  "goal.updated",
+  "goal.completed",
+  "goal.paused",
+  "goal.resumed",
+  "goal.continuation"
+]);
+var SessionEvent = z.object({
+  id: z.string().uuid(),
+  workspaceId: z.string().uuid(),
+  sessionId: z.string().uuid(),
+  sequence: z.number().int().positive(),
+  type: SessionEventType,
+  payload: z.unknown().default({}),
+  occurredAt: z.string(),
+  clientEventId: z.string().min(1).nullable().optional(),
+  turnId: z.string().uuid().nullable().optional()
+});
+var CreateSessionRequest = z.object({
+  initialMessage: z.string().min(1),
+  resources: z.array(ResourceRef).default([]),
+  tools: z.array(ToolRef).default([]),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+  model: z.string().min(1).optional(),
+  reasoningEffort: ReasoningEffort.optional(),
+  sandboxBackend: SandboxBackend.optional(),
+  // Workspace environment attachment is fixed at session creation; follow-up
+  // user.message events cannot switch or add one.
+  environmentId: z.string().uuid().optional(),
+  goal: GoalSpec.optional(),
+  clientEventId: z.string().min(1).optional(),
+  // Workspace-scoped CREATE idempotency key: collapses concurrent/retried
+  // create calls carrying the same key to a single session (partial unique
+  // index on (workspace_id, create_idempotency_key)). Distinct from
+  // clientEventId, whose uniqueness is per-session and so cannot dedup the
+  // creation of a brand-new session. Absent means no create-dedup (each call
+  // is an independent create).
+  idempotencyKey: z.string().min(1).max(200).optional(),
+  // Permissions the session's first-party MCP token should carry instead of
+  // the fixed worker default — how an operator hands a manager-style session
+  // the orchestration/environment/github tools. Capped at creation: every
+  // requested permission must be held by the creating grant (no escalation).
+  firstPartyMcpPermissions: z.array(Permission).optional()
+});
+var ClientSessionEvent = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("user.message"),
+    clientEventId: z.string().min(1).optional(),
+    payload: z.object({
+      text: z.string().min(1),
+      resources: z.array(ResourceRef).default([]),
+      tools: z.array(ToolRef).default([]),
+      model: z.string().min(1).optional(),
+      reasoningEffort: ReasoningEffort.optional()
+    })
+  }),
+  z.object({
+    type: z.literal("user.interrupt"),
+    clientEventId: z.string().min(1).optional(),
+    payload: z.object({ reason: z.string().optional() }).default({})
+  }),
+  z.object({
+    type: z.literal("user.approvalDecision"),
+    clientEventId: z.string().min(1).optional(),
+    payload: z.object({
+      approvalId: z.string().min(1),
+      decision: z.enum(["approve", "reject"]),
+      message: z.string().optional()
+    })
+  })
+]);
+var SessionBusMessage = z.object({
+  workspaceId: z.string().uuid(),
+  sessionId: z.string().uuid(),
+  events: z.array(SessionEvent).min(1)
+});
+var GitHubAppManifestCreate = z.object({
+  appName: z.string().optional(),
+  organization: z.string().optional(),
+  public: z.boolean().default(false),
+  includeCiPermissions: z.boolean().default(true)
+});
+var GitHubRepository = z.object({
+  id: z.number().int(),
+  installationId: z.number().int(),
+  fullName: z.string(),
+  name: z.string(),
+  private: z.boolean(),
+  htmlUrl: z.string(),
+  cloneUrl: z.string(),
+  defaultBranch: z.string(),
+  accountLogin: z.string(),
+  accountType: z.string().nullable()
+});
+var ClientAuthConfig = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("none")
+  }),
+  z.object({
+    mode: z.literal("deploymentKey"),
+    headerName: z.literal("x-opengeni-access-key")
+  }),
+  z.object({
+    mode: z.literal("configuredToken"),
+    headerName: z.literal("authorization"),
+    scheme: z.literal("bearer")
+  }),
+  z.object({
+    mode: z.literal("managedSession"),
+    session: z.literal("cookie")
+  })
+]);
+var ClientConfig = z.object({
+  deploymentRevision: z.string(),
+  defaultModel: z.string(),
+  allowedModels: z.array(z.string()).min(1),
+  defaultReasoningEffort: ReasoningEffort,
+  allowedReasoningEfforts: z.array(ReasoningEffort).min(1),
+  mcpServers: z.array(z.object({
+    id: z.string(),
+    name: z.string()
+  })).default([]),
+  fileUploads: z.object({
+    enabled: z.boolean(),
+    maxSizeBytes: z.number().int().positive()
+  }),
+  productAccessMode: ProductAccessMode,
+  auth: ClientAuthConfig.default({ mode: "none" })
+});
+function base64UrlEncode(value) {
+  return Buffer.from(value, "utf8").toString("base64url");
+}
+function base64UrlDecode(value) {
+  return Buffer.from(value, "base64url").toString("utf8");
+}
+async function hmacSha256Base64Url(secret, value) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(value));
+  return Buffer.from(signature).toString("base64url");
+}
+function constantTimeEqual(actual, expected) {
+  const actualBytes = new TextEncoder().encode(actual);
+  const expectedBytes = new TextEncoder().encode(expected);
+  if (actualBytes.length !== expectedBytes.length) {
+    return false;
+  }
+  let diff = 0;
+  for (let index = 0; index < actualBytes.length; index += 1) {
+    diff |= actualBytes[index] ^ expectedBytes[index];
+  }
+  return diff === 0;
+}
+export {
+  AccessContext,
+  AccessGrant,
+  AccountGrant,
+  AccountRole,
+  AddDocumentRequest,
+  ApiKey,
+  BillingBalance,
+  BillingMode,
+  CLEARED_RUN_STATE_BLOB,
+  CLEARED_RUN_STATE_MARKER,
+  CapabilityCatalogItem,
+  CapabilityCatalogResponse,
+  CapabilityInstallation,
+  CapabilityInstallationStatus,
+  CapabilityKind,
+  CapabilityPack,
+  CapabilityPackConnector,
+  CapabilityPackConnectorAuthModel,
+  CapabilityPackKnowledge,
+  CapabilityPackScheduledTaskTemplate,
+  CapabilityPackSkill,
+  CapabilityPackSkillFile,
+  CapabilityRuntime,
+  CapabilitySource,
+  ClearSessionContextRequest,
+  ClientAuthConfig,
+  ClientConfig,
+  ClientSessionEvent,
+  CompactSessionContextRequest,
+  CompactSessionContextResult,
+  CompleteFileUploadResponse,
+  CreateApiKeyRequest,
+  CreateApiKeyResponse,
+  CreateCapabilityCatalogItemRequest,
+  CreateCheckoutRequest,
+  CreateCheckoutResponse,
+  CreateDocumentBaseRequest,
+  CreateFileUploadRequest,
+  CreateFileUploadResponse,
+  CreateScheduledTaskRequest,
+  CreateSessionRequest,
+  CreateSocialConnectionRequest,
+  CreateSocialPostRequest,
+  CreateWorkspaceEnvironmentRequest,
+  CreateWorkspaceRequest,
+  DelegatedAccessTokenPayload,
+  DiscoverMcpCapabilitiesResponse,
+  Document,
+  DocumentBase,
+  DocumentSearchRequest,
+  DocumentSearchResult,
+  DocumentStatus,
+  EnableCapabilityRequest,
+  EnablePackRequest,
+  EntitlementValue,
+  Entitlements,
+  EntitlementsMode,
+  ErrorCode,
+  ErrorEnvelope,
+  FileAsset,
+  FileDownloadUrlResponse,
+  FileResourceRef,
+  FileStatus,
+  FileUploadStatus,
+  GitHubAppManifestCreate,
+  GitHubRepository,
+  GoalSpec,
+  LimitAction,
+  LimitDecision,
+  ManagedAccount,
+  MarketingDailyAnalysisTaskRequest,
+  PackInstallation,
+  PackInstallationStatus,
+  PageInfo,
+  Permission,
+  ProductAccessMode,
+  ReasoningEffort,
+  RegisterCapabilityPackRequest,
+  ReorderSessionTurnsRequest,
+  RepositoryResourceRef,
+  ResourceRef,
+  ResourceRefConflictError,
+  SandboxBackend,
+  ScheduledTask,
+  ScheduledTaskAgentConfig,
+  ScheduledTaskOverlapPolicy,
+  ScheduledTaskRun,
+  ScheduledTaskRunMode,
+  ScheduledTaskRunStatus,
+  ScheduledTaskScheduleSpec,
+  ScheduledTaskStatus,
+  ScheduledTaskTriggerType,
+  Session,
+  SessionBusMessage,
+  SessionEvent,
+  SessionEventType,
+  SessionGoal,
+  SessionGoalCreatedBy,
+  SessionGoalPausedReason,
+  SessionGoalStatus,
+  SessionStatus,
+  SessionTurn,
+  SessionTurnSource,
+  SessionTurnStatus,
+  SetWorkspaceEnvironmentVariableRequest,
+  SocialConnection,
+  SocialConnectionStatus,
+  SocialPost,
+  SocialProvider,
+  StaticUsageLimits,
+  ToolRef,
+  TriggerScheduledTaskRequest,
+  UpdateScheduledTaskRequest,
+  UpdateSessionGoalRequest,
+  UpdateSessionTurnRequest,
+  UpdateWorkspaceEnvironmentRequest,
+  UpdateWorkspaceRequest,
+  UsageEvent,
+  UsageEventType,
+  UsageLimitsMode,
+  Workspace,
+  WorkspaceEnvironment,
+  WorkspaceEnvironmentVariableMetadata,
+  WorkspaceEnvironmentVariableName,
+  WorkspaceRegisteredPack,
+  isClearedRunStateBlob,
+  mergeResourceRefs,
+  mergeToolRefs,
+  paginated,
+  reasoningEffortForMetadata,
+  resourceIdentityKey,
+  signDelegatedAccessToken,
+  stableJson,
+  verifyDelegatedAccessToken
+};
+//# sourceMappingURL=index.js.map