@cognidesk/studio-contracts 0.0.3-dev.6 → 0.0.3-dev.8

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/index.ts
+// src/auth.ts
 import { z } from "zod";
 var StudioRoleSchema = z.enum(["viewer", "dashboard_editor", "operator", "admin"]);
 var StudioPermissionSchema = z.enum([
@@ -18,330 +18,470 @@ var permissionsByRole = {
 function roleHasPermission(role, permission) {
   return permissionsByRole[role].includes(permission);
 }
-var StudioTargetManifestSchema = z.object({
-  version: z.literal(1),
-  target: z.object({
-    id: z.string().min(1),
-    name: z.string().min(1),
-    environment: z.string().default("local")
-  }),
-  runtime: z.object({
-    baseUrl: z.string().url(),
-    apiBasePath: z.string().default("/api"),
-    studioAdapterBasePath: z.string().default("/api/studio"),
-    serviceAuthHeader: z.string().default("authorization")
-  }),
-  telemetry: z.object({
-    sources: z.array(z.object({
-      id: z.string().min(1),
-      label: z.string().min(1),
-      kind: z.enum(["prometheus", "tempo", "otel-http"]),
-      baseUrl: z.string().url(),
-      headers: z.record(z.string(), z.string()).optional()
-    })).default([])
-  }).default({ sources: [] }),
-  source: z.object({
-    provider: z.literal("github"),
-    owner: z.string().min(1),
-    repo: z.string().min(1),
-    defaultBranch: z.string().default("main"),
-    root: z.string().default(".")
-  }),
-  code: z.object({
-    allowedPaths: z.array(z.string()).default([]),
-    validationCommands: z.array(z.object({
-      id: z.string().min(1),
-      label: z.string().min(1),
-      command: z.string().min(1),
-      workingDirectory: z.string().default(".")
+
+// src/configuration.ts
+import { z as z2 } from "zod";
+var StudioChannelAudienceSchema = z2.enum(["customer-facing", "internal-support", "mixed"]);
+var StudioProviderDirectionSchema = z2.enum([
+  "receive-only",
+  "send-only",
+  "inbound-only",
+  "outbound-only",
+  "bidirectional"
+]);
+var StudioProviderTrustLevelSchema = z2.enum(["official", "verified", "community", "experimental"]);
+var StudioProviderCoverageScopeSchema = z2.enum([
+  "support-workflow-subset",
+  "provider-api-subset",
+  "connector-required",
+  "local-protocol",
+  "full-provider-api"
+]);
+var StudioActionAudienceSchema = StudioChannelAudienceSchema;
+var StudioChannelCapabilitySchema = z2.object({
+  capability: z2.string().min(1),
+  label: z2.string().optional(),
+  description: z2.string().optional(),
+  extension: z2.boolean().default(false),
+  audiences: z2.array(StudioActionAudienceSchema).default([]),
+  requiresCredential: z2.boolean().default(false),
+  sideEffect: z2.boolean().default(false),
+  exposesSensitiveData: z2.boolean().default(false),
+  changesWorkflow: z2.boolean().default(false),
+  providerObjects: z2.array(z2.object({
+    kind: z2.string().min(1),
+    label: z2.string().optional(),
+    description: z2.string().optional(),
+    schemaName: z2.string().optional(),
+    metadata: z2.record(z2.string(), z2.unknown()).optional()
+  })).default([]),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
+});
+var StudioProviderPackageSummarySchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  packageName: z2.string().min(1),
+  provider: z2.string().min(1),
+  category: z2.string().min(1),
+  trustLevel: StudioProviderTrustLevelSchema,
+  directions: z2.array(StudioProviderDirectionSchema),
+  channelAudiences: z2.array(StudioChannelAudienceSchema),
+  coverage: z2.object({
+    scope: StudioProviderCoverageScopeSchema,
+    notes: z2.array(z2.string()).default([]),
+    evidence: z2.array(z2.object({
+      label: z2.string().min(1),
+      url: z2.string().url().optional()
     })).default([])
-  }).default({ allowedPaths: [], validationCommands: [] }),
-  dashboards: z.object({
-    artifactBucket: z.string().min(1),
-    artifactPrefix: z.string().default("studio/dashboards")
-  }),
-  operator: z.object({
-    instructionsPath: z.string().default("AGENTS.md"),
-    skillPacks: z.array(z.string()).default(["@cognidesk/studio-operator-skills"]),
-    models: z.array(z.object({
-      id: z.string().min(1),
-      label: z.string().min(1),
-      provider: z.string().min(1),
-      model: z.string().min(1),
-      default: z.boolean().optional()
-    })).default([]),
-    allowedCredentialGrants: z.array(z.enum([
-      "github",
-      "package_registry",
-      "telemetry",
-      "artifact_store",
-      "studio_adapter",
-      "backend_service"
-    ])).default([])
   }).default({
-    instructionsPath: "AGENTS.md",
-    skillPacks: ["@cognidesk/studio-operator-skills"],
-    models: [],
-    allowedCredentialGrants: []
-  })
+    scope: "support-workflow-subset",
+    notes: [
+      "Coverage is scoped to Cognidesk support workflows unless this manifest explicitly declares full-provider-api coverage."
+    ],
+    evidence: []
+  }),
+  capabilities: z2.array(StudioChannelCapabilitySchema),
+  credentialRequirements: z2.array(z2.object({
+    id: z2.string().min(1),
+    label: z2.string().optional(),
+    description: z2.string().optional(),
+    scopes: z2.array(z2.string()).default([]),
+    required: z2.boolean().default(true),
+    metadata: z2.record(z2.string(), z2.unknown()).optional()
+  })).default([]),
+  privacyNotes: z2.array(z2.string()).default([]),
+  limitations: z2.array(z2.string()).default([]),
+  maintainers: z2.array(z2.object({
+    name: z2.string().min(1),
+    type: z2.enum(["official", "partner", "community", "unknown"]).default("unknown"),
+    url: z2.string().url().optional()
+  })).default([]),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-var StudioTargetOverlaySchema = z.object({
-  version: z.literal(1).optional(),
-  target: z.object({
-    id: z.string().min(1).optional(),
-    name: z.string().min(1).optional(),
-    environment: z.string().optional()
-  }).optional(),
-  runtime: z.object({
-    baseUrl: z.string().url().optional(),
-    apiBasePath: z.string().optional(),
-    studioAdapterBasePath: z.string().optional(),
-    serviceAuthHeader: z.string().optional()
-  }).optional(),
-  telemetry: z.object({
-    sources: z.array(z.object({
-      id: z.string().min(1),
-      label: z.string().min(1),
-      kind: z.enum(["prometheus", "tempo", "otel-http"]),
-      baseUrl: z.string().url(),
-      headers: z.record(z.string(), z.string()).optional()
-    })).optional()
-  }).optional(),
-  source: z.object({
-    provider: z.literal("github").optional(),
-    owner: z.string().min(1).optional(),
-    repo: z.string().min(1).optional(),
-    defaultBranch: z.string().optional(),
-    root: z.string().optional()
-  }).optional(),
-  code: z.object({
-    allowedPaths: z.array(z.string()).optional(),
-    validationCommands: z.array(z.object({
-      id: z.string().min(1),
-      label: z.string().min(1),
-      command: z.string().min(1),
-      workingDirectory: z.string().default(".")
-    })).optional()
-  }).optional(),
-  dashboards: z.object({
-    artifactBucket: z.string().min(1).optional(),
-    artifactPrefix: z.string().optional()
-  }).optional(),
-  operator: z.object({
-    instructionsPath: z.string().optional(),
-    skillPacks: z.array(z.string()).optional(),
-    models: z.array(z.object({
-      id: z.string().min(1),
-      label: z.string().min(1),
-      provider: z.string().min(1),
-      model: z.string().min(1),
-      default: z.boolean().optional()
-    })).optional(),
-    allowedCredentialGrants: z.array(z.enum([
-      "github",
-      "package_registry",
-      "telemetry",
-      "artifact_store",
-      "studio_adapter",
-      "backend_service"
-    ])).optional()
-  }).optional()
+var StudioCapabilityAvailabilitySchema = z2.object({
+  providerPackageId: z2.string().min(1).optional(),
+  capability: z2.string().min(1).optional(),
+  status: z2.enum(["registry-available", "installed", "configured", "enabled", "blocked"]),
+  enabledForChannels: z2.array(z2.string()).default([]),
+  enabledForAgents: z2.array(z2.string()).default([]),
+  enabledForJourneys: z2.array(z2.string()).default([]),
+  enabledForTools: z2.array(z2.string()).default([]),
+  blockers: z2.array(z2.object({
+    code: z2.string().min(1),
+    message: z2.string().min(1),
+    kind: z2.enum([
+      "missing-policy",
+      "missing-configuration",
+      "missing-credentials",
+      "provider-unsupported",
+      "permission-blocked",
+      "unknown"
+    ]).default("unknown")
+  })).default([]),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-function mergeStudioTargetManifest(base, overlay = {}) {
-  return StudioTargetManifestSchema.parse(deepMerge(base, overlay));
-}
-function deepMerge(base, overlay) {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(overlay)) {
-    if (value === void 0) continue;
-    const baseValue = result[key];
-    result[key] = isPlainRecord(baseValue) && isPlainRecord(value) ? deepMerge(baseValue, value) : value;
-  }
-  return result;
-}
-function isPlainRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-var StudioToolSummarySchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  sideEffect: z.boolean()
+var StudioProviderCredentialStatusSchema = z2.object({
+  providerPackageId: z2.string().min(1).optional(),
+  requirementId: z2.string().min(1),
+  state: z2.enum([
+    "not-required",
+    "required",
+    "configured",
+    "missing",
+    "expired",
+    "insufficient-scope",
+    "permission-blocked",
+    "unavailable"
+  ]),
+  scopes: z2.array(z2.string()).default([]),
+  expiresAt: z2.string().optional(),
+  message: z2.string().optional()
 });
-var StudioKnowledgeSummarySchema = z.object({
-  name: z.string()
+var StudioChannelPolicyDetailSchema = z2.object({
+  id: z2.string().min(1),
+  owner: z2.string().optional(),
+  value: z2.unknown()
 });
-var StudioWidgetSummarySchema = z.object({
-  kind: z.string()
+var StudioChannelFlowActivationSchema = z2.object({
+  journeyId: z2.string().min(1),
+  enabled: z2.boolean().default(true),
+  reason: z2.string().optional(),
+  providerPackageIds: z2.array(z2.string()).default([]),
+  policyIds: z2.array(z2.string()).default([]),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-var StudioJourneyGraphStateSchema = z.object({
-  id: z.string(),
-  parentId: z.string().optional(),
-  initialStateId: z.string().optional(),
-  type: z.enum(["state", "parallel", "final"]),
-  instructions: z.string().optional(),
-  summary: z.string().optional(),
-  collected: z.array(z.object({
-    path: z.string(),
-    required: z.boolean(),
-    extract: z.boolean()
-  })),
-  transitions: z.array(z.object({
-    kind: z.enum(["event", "conversational"]),
-    targetId: z.string(),
-    eventName: z.string().optional(),
-    description: z.string().optional(),
-    priority: z.number().optional()
-  })),
-  actions: z.array(z.object({
-    type: z.enum(["entry", "exit", "transition"]),
-    name: z.string()
-  })),
-  requiresVisit: z.boolean()
+var StudioChannelOutboundPolicySchema = z2.object({
+  enabled: z2.boolean().default(false),
+  providerPackageIds: z2.array(z2.string()).default([]),
+  requiresProviderOutboundSupport: z2.boolean().default(true),
+  policyIds: z2.array(z2.string()).default([]),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-var StudioJourneyGraphSchema = z.object({
-  id: z.string(),
-  kind: z.enum(["stateMachine", "delegation"]),
-  initialStateId: z.string().optional(),
-  alternateEntries: z.array(z.object({
-    stateId: z.string(),
-    description: z.string().optional(),
-    priority: z.number().optional()
-  })).optional(),
-  states: z.array(StudioJourneyGraphStateSchema)
+var StudioChannelBehaviorPolicySchema = z2.object({
+  tone: z2.string().min(1).optional(),
+  maxWords: z2.number().int().positive().optional(),
+  maxCharacters: z2.number().int().positive().optional(),
+  allowMarkdown: z2.boolean().optional(),
+  allowWidgets: z2.boolean().optional(),
+  draftFirst: z2.boolean().optional(),
+  approval: z2.unknown().optional(),
+  sensitiveData: z2.unknown().optional(),
+  media: z2.unknown().optional(),
+  handoff: z2.unknown().optional()
+}).passthrough();
+var StudioChannelHandoffPolicySchema = z2.object({
+  enabled: z2.boolean().default(false),
+  providerPackageIds: z2.array(z2.string()).default([]),
+  destinations: z2.array(z2.string()).default([]),
+  sdkControlled: z2.boolean().optional(),
+  policyIds: z2.array(z2.string()).default([]),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-var StudioJourneySummarySchema = z.object({
-  id: z.string(),
-  kind: z.enum(["stateMachine", "delegation"]),
-  condition: z.string(),
-  examples: z.array(z.string()),
-  tags: z.array(z.string()),
-  priority: z.number(),
-  stickiness: z.enum(["low", "medium", "high"]),
-  alwaysInclude: z.boolean(),
-  graph: StudioJourneyGraphSchema,
-  mermaid: z.string(),
-  delegation: z.object({
-    goal: z.string(),
-    instructions: z.string().optional(),
-    completeWhen: z.array(z.string()),
-    tools: z.array(StudioToolSummarySchema)
+var StudioChannelConfigurationSchema = z2.object({
+  id: z2.string().min(1).optional(),
+  channel: z2.string().min(1),
+  audience: StudioChannelAudienceSchema.optional(),
+  enabled: z2.boolean().default(true),
+  channelSetIds: z2.array(z2.string()).default([]),
+  providerPackageIds: z2.array(z2.string()).default([]),
+  enabledCapabilities: z2.array(z2.string()).default([]),
+  policyIds: z2.array(z2.string()).default([]),
+  policyDetails: z2.array(StudioChannelPolicyDetailSchema).default([]),
+  flowActivations: z2.array(StudioChannelFlowActivationSchema).default([]),
+  behavior: StudioChannelBehaviorPolicySchema.optional(),
+  outbound: StudioChannelOutboundPolicySchema.optional(),
+  handoff: StudioChannelHandoffPolicySchema.optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
+});
+var StudioChannelSetConfigurationSchema = z2.object({
+  id: z2.string().min(1),
+  label: z2.string().optional(),
+  enabled: z2.boolean().default(true),
+  channelIds: z2.array(z2.string()).default([]),
+  channels: z2.array(z2.string()).default([]),
+  conversationContinuity: z2.object({
+    mode: z2.enum(["new-conversation", "link-existing", "sdk-decides"]).default("sdk-decides"),
+    crossChannel: z2.boolean().default(false),
+    policy: z2.string().optional()
   }).optional(),
-  tools: z.array(StudioToolSummarySchema),
-  knowledge: z.array(StudioKnowledgeSummarySchema)
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-var StudioAgentIntrospectionSchema = z.object({
-  targetId: z.string(),
-  agent: z.object({
-    id: z.string(),
-    instructions: z.string(),
-    logLevel: z.string().optional(),
-    journeyCount: z.number().int(),
-    toolCount: z.number().int(),
-    knowledgeCount: z.number().int(),
-    widgetCount: z.number().int()
-  }),
-  journeys: z.array(StudioJourneySummarySchema),
-  tools: z.array(StudioToolSummarySchema),
-  knowledge: z.array(StudioKnowledgeSummarySchema),
-  widgets: z.array(StudioWidgetSummarySchema),
-  capturedAt: z.string()
+var StudioProviderReadinessSchema = z2.object({
+  providerPackageId: z2.string().min(1),
+  status: z2.enum([
+    "unknown",
+    "not-configured",
+    "configured",
+    "ready",
+    "blocked",
+    "live-verified",
+    "sandbox-verified",
+    "scoped-verified",
+    "full-api-verified"
+  ]),
+  checkedAt: z2.string().optional(),
+  checkSource: z2.string().optional(),
+  live: z2.boolean().optional(),
+  sandbox: z2.boolean().optional(),
+  blockers: StudioCapabilityAvailabilitySchema.shape.blockers.default([]),
+  remediationActions: z2.array(z2.object({
+    id: z2.string().min(1),
+    label: z2.string().min(1),
+    kind: z2.enum(["configure", "authorize", "verify", "read-docs", "contact-provider", "custom"]).default("custom"),
+    metadata: z2.record(z2.string(), z2.unknown()).optional()
+  })).default([]),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
 });
-var StudioConversationSummarySchema = z.object({
-  id: z.string(),
-  agentId: z.string(),
-  lifecycle: z.enum(["active", "handoff", "closed"]),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  activeJourneyId: z.string().optional(),
-  activeStateIds: z.array(z.string()).default([]),
-  eventCount: z.number().int().optional(),
-  traceIds: z.array(z.string()).default([])
+var StudioConfigurationSurfaceSchema = z2.object({
+  targetId: z2.string().min(1),
+  channelSets: z2.array(StudioChannelSetConfigurationSchema).default([]),
+  channels: z2.array(StudioChannelConfigurationSchema).default([]),
+  providerPackages: z2.array(StudioProviderPackageSummarySchema).default([]),
+  capabilityAvailability: z2.array(StudioCapabilityAvailabilitySchema).default([]),
+  credentialStatuses: z2.array(StudioProviderCredentialStatusSchema).default([]),
+  providerReadiness: z2.array(StudioProviderReadinessSchema).default([]),
+  policyIds: z2.array(z2.string()).default([]),
+  capturedAt: z2.string()
 });
-var StudioTelemetryMetricPointSchema = z.object({
-  timestamp: z.string(),
-  value: z.number(),
-  labels: z.record(z.string(), z.string()).default({})
+var StudioConfigurationMutationOperationSchema = z2.object({
+  op: z2.string().min(1),
+  channelId: z2.string().min(1).optional(),
+  channelSetId: z2.string().min(1).optional(),
+  providerPackageId: z2.string().min(1).optional(),
+  journeyId: z2.string().min(1).optional(),
+  policyId: z2.string().min(1).optional(),
+  value: z2.unknown().optional()
+}).passthrough();
+var StudioConfigurationMutationRequestSchema = z2.object({
+  requestId: z2.string().min(1).optional(),
+  targetId: z2.string().min(1),
+  reason: z2.string().min(1),
+  operations: z2.array(StudioConfigurationMutationOperationSchema).min(1),
+  actor: z2.object({
+    id: z2.string().min(1).optional(),
+    role: StudioRoleSchema.optional()
+  }).passthrough().optional()
+}).passthrough();
+var StudioConfigurationMutationResultSchema = z2.object({
+  requestId: z2.string().min(1),
+  targetId: z2.string().min(1),
+  accepted: z2.boolean(),
+  applied: z2.boolean().default(false),
+  status: z2.enum(["accepted", "applied", "rejected", "validation-failed", "unsupported"]),
+  message: z2.string().optional(),
+  blockers: z2.array(z2.object({
+    code: z2.string().min(1),
+    message: z2.string().min(1),
+    kind: z2.enum([
+      "missing-policy",
+      "missing-configuration",
+      "missing-credentials",
+      "provider-unsupported",
+      "permission-blocked",
+      "unknown",
+      "validation"
+    ]).default("unknown")
+  })).default([])
+}).passthrough();
+
+// src/dashboards.ts
+import { z as z3 } from "zod";
+var StudioTelemetryMetricPointSchema = z3.object({
+  timestamp: z3.string(),
+  value: z3.number(),
+  labels: z3.record(z3.string(), z3.string()).default({})
 });
-var StudioTraceSummarySchema = z.object({
-  traceId: z.string(),
-  rootSpanName: z.string().optional(),
-  serviceName: z.string().optional(),
-  startedAt: z.string().optional(),
-  durationMs: z.number().optional(),
-  status: z.enum(["ok", "error", "unknown"]).default("unknown"),
-  spanCount: z.number().int().optional()
+var StudioTraceSummarySchema = z3.object({
+  traceId: z3.string(),
+  rootSpanName: z3.string().optional(),
+  serviceName: z3.string().optional(),
+  startedAt: z3.string().optional(),
+  durationMs: z3.number().optional(),
+  status: z3.enum(["ok", "error", "unknown"]).default("unknown"),
+  spanCount: z3.number().int().optional()
 });
-var StudioDashboardDataCapabilitySchema = z.enum([
+var StudioDashboardDataCapabilitySchema = z3.enum([
   "telemetry.traces",
   "telemetry.metrics",
   "cognidesk.agent",
+  "cognidesk.configuration",
   "cognidesk.conversations",
   "cognidesk.events",
   "cognidesk.snapshots"
 ]);
-var StudioDashboardDataQuerySchema = z.object({
+var StudioDashboardDataQuerySchema = z3.object({
   capability: StudioDashboardDataCapabilitySchema,
-  targetId: z.string(),
-  params: z.record(z.string(), z.unknown()).default({})
+  targetId: z3.string(),
+  params: z3.record(z3.string(), z3.unknown()).default({})
 });
-var StudioDashboardDatasetSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  description: z.string().optional(),
-  mode: z.enum(["static", "live"]).default("static"),
-  refreshMs: z.number().int().positive().optional(),
+var StudioDashboardDatasetSchema = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  description: z3.string().optional(),
+  mode: z3.enum(["static", "live"]).default("static"),
+  refreshMs: z3.number().int().positive().optional(),
   source: StudioDashboardDataQuerySchema,
-  capturedAt: z.string(),
-  data: z.unknown()
+  capturedAt: z3.string(),
+  data: z3.unknown()
 });
-var StudioDashboardWidgetSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  kind: z.enum(["metric", "line", "bar", "donut", "table", "insight"]),
-  datasetId: z.string().optional(),
-  description: z.string().optional(),
-  valuePath: z.string().optional(),
-  labelPath: z.string().optional(),
-  xPath: z.string().optional(),
-  yPath: z.string().optional(),
-  series: z.array(z.object({
-    label: z.string(),
-    path: z.string()
+var StudioDashboardWidgetSchema = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  kind: z3.enum(["metric", "line", "bar", "donut", "table", "insight"]),
+  datasetId: z3.string().optional(),
+  description: z3.string().optional(),
+  valuePath: z3.string().optional(),
+  labelPath: z3.string().optional(),
+  xPath: z3.string().optional(),
+  yPath: z3.string().optional(),
+  series: z3.array(z3.object({
+    label: z3.string(),
+    path: z3.string()
   })).optional(),
-  unit: z.string().optional(),
-  tone: z.enum(["slate", "blue", "green", "amber", "red", "violet", "teal"]).optional(),
-  limit: z.number().int().positive().optional(),
-  columns: z.array(z.object({
-    label: z.string(),
-    path: z.string()
+  unit: z3.string().optional(),
+  tone: z3.enum(["slate", "blue", "green", "amber", "red", "violet", "teal"]).optional(),
+  limit: z3.number().int().positive().optional(),
+  columns: z3.array(z3.object({
+    label: z3.string(),
+    path: z3.string()
   })).optional()
 }).passthrough();
-var StudioDashboardSpecSchema = z.object({
-  layout: z.enum(["overview", "timeseries", "comparison", "operations"]).default("overview"),
-  summary: z.string().optional(),
-  widgets: z.array(StudioDashboardWidgetSchema).default([])
+var StudioDashboardSpecSchema = z3.object({
+  layout: z3.enum(["overview", "timeseries", "comparison", "operations"]).default("overview"),
+  summary: z3.string().optional(),
+  widgets: z3.array(StudioDashboardWidgetSchema).default([])
 }).passthrough();
-var StudioDashboardArtifactSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  slug: z.string(),
-  description: z.string().optional(),
-  version: z.number().int().positive(),
-  status: z.enum(["draft", "published", "archived"]),
-  ownerUserId: z.string(),
-  targetId: z.string(),
-  artifactKey: z.string(),
-  renderer: z.object({
-    kind: z.literal("react-component"),
-    entry: z.string().default("Dashboard"),
+var StudioDashboardArtifactSchema = z3.object({
+  id: z3.string(),
+  title: z3.string(),
+  slug: z3.string(),
+  description: z3.string().optional(),
+  version: z3.number().int().positive(),
+  status: z3.enum(["draft", "published", "archived"]),
+  ownerUserId: z3.string(),
+  targetId: z3.string(),
+  artifactKey: z3.string(),
+  renderer: z3.object({
+    kind: z3.literal("react-component"),
+    entry: z3.string().default("Dashboard"),
     spec: StudioDashboardSpecSchema.optional()
   }),
-  datasets: z.array(StudioDashboardDatasetSchema).default([]),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  publishedAt: z.string().optional()
+  datasets: z3.array(StudioDashboardDatasetSchema).default([]),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  publishedAt: z3.string().optional()
+});
+
+// src/introspection.ts
+import { z as z5 } from "zod";
+
+// src/summaries.ts
+import { z as z4 } from "zod";
+var StudioToolSummarySchema = z4.object({
+  name: z4.string(),
+  description: z4.string().optional(),
+  sideEffect: z4.boolean()
+});
+var StudioKnowledgeSummarySchema = z4.object({
+  name: z4.string()
+});
+var StudioWidgetSummarySchema = z4.object({
+  kind: z4.string()
+});
+
+// src/introspection.ts
+var StudioJourneyGraphStateSchema = z5.object({
+  id: z5.string(),
+  parentId: z5.string().optional(),
+  initialStateId: z5.string().optional(),
+  type: z5.enum(["state", "parallel", "final"]),
+  instructions: z5.string().optional(),
+  summary: z5.string().optional(),
+  collected: z5.array(z5.object({
+    path: z5.string(),
+    required: z5.boolean(),
+    extract: z5.boolean()
+  })),
+  transitions: z5.array(z5.object({
+    kind: z5.enum(["event", "conversational"]),
+    targetId: z5.string(),
+    eventName: z5.string().optional(),
+    description: z5.string().optional(),
+    priority: z5.number().optional()
+  })),
+  actions: z5.array(z5.object({
+    type: z5.enum(["entry", "exit", "transition"]),
+    name: z5.string()
+  })),
+  requiresVisit: z5.boolean()
+});
+var StudioJourneyGraphSchema = z5.object({
+  id: z5.string(),
+  kind: z5.enum(["stateMachine", "delegation"]),
+  initialStateId: z5.string().optional(),
+  alternateEntries: z5.array(z5.object({
+    stateId: z5.string(),
+    description: z5.string().optional(),
+    priority: z5.number().optional()
+  })).optional(),
+  states: z5.array(StudioJourneyGraphStateSchema)
+});
+var StudioJourneySummarySchema = z5.object({
+  id: z5.string(),
+  kind: z5.enum(["stateMachine", "delegation"]),
+  condition: z5.string(),
+  examples: z5.array(z5.string()),
+  tags: z5.array(z5.string()),
+  priority: z5.number(),
+  stickiness: z5.enum(["low", "medium", "high"]),
+  alwaysInclude: z5.boolean(),
+  graph: StudioJourneyGraphSchema,
+  mermaid: z5.string(),
+  delegation: z5.object({
+    goal: z5.string(),
+    instructions: z5.string().optional(),
+    completeWhen: z5.array(z5.string()),
+    tools: z5.array(StudioToolSummarySchema)
+  }).optional(),
+  tools: z5.array(StudioToolSummarySchema),
+  knowledge: z5.array(StudioKnowledgeSummarySchema)
+});
+var StudioAgentIntrospectionSchema = z5.object({
+  targetId: z5.string(),
+  agent: z5.object({
+    id: z5.string(),
+    instructions: z5.string(),
+    logLevel: z5.string().optional(),
+    journeyCount: z5.number().int(),
+    toolCount: z5.number().int(),
+    knowledgeCount: z5.number().int(),
+    widgetCount: z5.number().int(),
+    persona: z5.unknown().optional(),
+    channelPolicies: z5.record(z5.string(), z5.unknown()).optional(),
+    handoffPolicy: z5.unknown().optional()
+  }),
+  journeys: z5.array(StudioJourneySummarySchema),
+  tools: z5.array(StudioToolSummarySchema),
+  knowledge: z5.array(StudioKnowledgeSummarySchema),
+  widgets: z5.array(StudioWidgetSummarySchema),
+  configurationSurface: StudioConfigurationSurfaceSchema.optional(),
+  capturedAt: z5.string()
 });
-var StudioOperatorSurfaceSchema = z.enum([
+var StudioConversationSummarySchema = z5.object({
+  id: z5.string(),
+  agentId: z5.string(),
+  lifecycle: z5.enum(["active", "handoff", "closed"]),
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
+  activeJourneyId: z5.string().optional(),
+  activeStateIds: z5.array(z5.string()).default([]),
+  eventCount: z5.number().int().optional(),
+  traceIds: z5.array(z5.string()).default([])
+});
+
+// src/operator.ts
+import { z as z6 } from "zod";
+var StudioOperatorSurfaceSchema = z6.enum([
   "conversation",
   "evidence",
   "artifacts",
@@ -349,113 +489,116 @@ var StudioOperatorSurfaceSchema = z.enum([
   "validation_runs",
   "approvals"
 ]);
-var StudioOperatorReasoningEffortSchema = z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]);
-var StudioOperatorClientEventSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("session.start"),
-    sessionId: z.string().optional(),
-    targetId: z.string(),
-    modelId: z.string().optional(),
+var StudioOperatorReasoningEffortSchema = z6.enum(["none", "minimal", "low", "medium", "high", "xhigh"]);
+var StudioOperatorSessionIdSchema = z6.string().uuid();
+var StudioOperatorClientEventSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("session.start"),
+    sessionId: StudioOperatorSessionIdSchema.optional(),
+    targetId: z6.string(),
+    modelId: z6.string().optional(),
     reasoningEffort: StudioOperatorReasoningEffortSchema.optional(),
-    message: z.string().optional()
+    message: z6.string().optional()
   }),
-  z.object({
-    type: z.literal("turn.start"),
-    sessionId: z.string(),
-    message: z.string(),
-    modelId: z.string().optional(),
+  z6.object({
+    type: z6.literal("turn.start"),
+    sessionId: StudioOperatorSessionIdSchema,
+    message: z6.string(),
+    modelId: z6.string().optional(),
     reasoningEffort: StudioOperatorReasoningEffortSchema.optional()
   }),
-  z.object({
-    type: z.literal("turn.interrupt"),
-    sessionId: z.string()
+  z6.object({
+    type: z6.literal("turn.interrupt"),
+    sessionId: StudioOperatorSessionIdSchema
   }),
-  z.object({
-    type: z.literal("approval.resolve"),
-    sessionId: z.string(),
-    approvalId: z.string(),
-    approved: z.boolean(),
-    payload: z.unknown().optional()
+  z6.object({
+    type: z6.literal("approval.resolve"),
+    sessionId: StudioOperatorSessionIdSchema,
+    approvalId: z6.string(),
+    approved: z6.boolean(),
+    payload: z6.unknown().optional()
   })
 ]);
-var StudioOperatorServerEventSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("session.ready"),
-    sessionId: z.string(),
-    targetId: z.string(),
-    modelId: z.string().optional()
+var StudioOperatorServerEventSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.literal("session.ready"),
+    sessionId: StudioOperatorSessionIdSchema,
+    targetId: z6.string(),
+    modelId: z6.string().optional()
   }),
-  z.object({
-    type: z.literal("activity"),
-    sessionId: z.string(),
-    message: z.string(),
-    detail: z.string().optional(),
-    category: z.string().optional(),
-    input: z.unknown().optional(),
-    output: z.unknown().optional(),
+  z6.object({
+    type: z6.literal("activity"),
+    sessionId: StudioOperatorSessionIdSchema,
+    message: z6.string(),
+    detail: z6.string().optional(),
+    category: z6.string().optional(),
+    input: z6.unknown().optional(),
+    output: z6.unknown().optional(),
     surface: StudioOperatorSurfaceSchema.optional()
   }),
-  z.object({
-    type: z.literal("assistant.delta"),
-    sessionId: z.string(),
-    delta: z.string()
+  z6.object({
+    type: z6.literal("assistant.delta"),
+    sessionId: StudioOperatorSessionIdSchema,
+    delta: z6.string()
   }),
-  z.object({
-    type: z.literal("artifact.upserted"),
-    sessionId: z.string(),
-    artifact: z.record(z.string(), z.unknown())
+  z6.object({
+    type: z6.literal("artifact.upserted"),
+    sessionId: StudioOperatorSessionIdSchema,
+    artifact: z6.record(z6.string(), z6.unknown())
   }),
-  z.object({
-    type: z.literal("reasoning.summary"),
-    sessionId: z.string(),
-    summary: z.string()
+  z6.object({
+    type: z6.literal("reasoning.summary"),
+    sessionId: StudioOperatorSessionIdSchema,
+    summary: z6.string()
   }),
-  z.object({
-    type: z.literal("tool.started"),
-    sessionId: z.string(),
-    name: z.string(),
-    input: z.unknown().optional()
+  z6.object({
+    type: z6.literal("tool.started"),
+    sessionId: StudioOperatorSessionIdSchema,
+    name: z6.string(),
+    input: z6.unknown().optional()
   }),
-  z.object({
-    type: z.literal("tool.completed"),
-    sessionId: z.string(),
-    name: z.string(),
-    output: z.unknown().optional()
+  z6.object({
+    type: z6.literal("tool.completed"),
+    sessionId: StudioOperatorSessionIdSchema,
+    name: z6.string(),
+    output: z6.unknown().optional()
   }),
-  z.object({
-    type: z.literal("sandbox.diff.updated"),
-    sessionId: z.string(),
-    summary: z.string(),
-    files: z.array(z.object({
-      path: z.string(),
-      status: z.enum(["added", "modified", "deleted", "renamed"])
+  z6.object({
+    type: z6.literal("sandbox.diff.updated"),
+    sessionId: StudioOperatorSessionIdSchema,
+    summary: z6.string(),
+    files: z6.array(z6.object({
+      path: z6.string(),
+      status: z6.enum(["added", "modified", "deleted", "renamed"])
     }))
   }),
-  z.object({
-    type: z.literal("validation.completed"),
-    sessionId: z.string(),
-    commandId: z.string(),
-    exitCode: z.number().int(),
-    output: z.string()
+  z6.object({
+    type: z6.literal("validation.completed"),
+    sessionId: StudioOperatorSessionIdSchema,
+    commandId: z6.string(),
+    exitCode: z6.number().int(),
+    output: z6.string()
   }),
-  z.object({
-    type: z.literal("approval.required"),
-    sessionId: z.string(),
-    approvalId: z.string(),
-    action: z.enum(["publish_dashboard", "create_pr", "grant_credentials"]),
-    title: z.string(),
-    payload: z.unknown()
+  z6.object({
+    type: z6.literal("approval.required"),
+    sessionId: StudioOperatorSessionIdSchema,
+    approvalId: z6.string(),
+    action: z6.enum(["publish_dashboard", "create_pr", "grant_credentials", "update_configuration"]),
+    title: z6.string(),
+    payload: z6.unknown()
   }),
-  z.object({
-    type: z.literal("turn.completed"),
-    sessionId: z.string()
+  z6.object({
+    type: z6.literal("turn.completed"),
+    sessionId: StudioOperatorSessionIdSchema
   }),
-  z.object({
-    type: z.literal("error"),
-    sessionId: z.string().optional(),
-    message: z.string()
+  z6.object({
+    type: z6.literal("error"),
+    sessionId: StudioOperatorSessionIdSchema.optional(),
+    message: z6.string()
   })
 ]);
+
+// src/responses.ts
 function jsonResponse(value, init) {
   return new Response(JSON.stringify(value), {
     ...init,
@@ -465,8 +608,170 @@ function jsonResponse(value, init) {
     }
   });
 }
+
+// src/target-manifest.ts
+import { z as z7 } from "zod";
+var StudioTargetManifestSchema = z7.object({
+  version: z7.literal(1),
+  target: z7.object({
+    id: z7.string().min(1),
+    name: z7.string().min(1),
+    environment: z7.string().default("local")
+  }),
+  runtime: z7.object({
+    baseUrl: z7.string().url(),
+    apiBasePath: z7.string().default("/api"),
+    studioAdapterBasePath: z7.string().default("/api/studio"),
+    serviceAuthHeader: z7.string().default("authorization")
+  }),
+  telemetry: z7.object({
+    sources: z7.array(z7.object({
+      id: z7.string().min(1),
+      label: z7.string().min(1),
+      kind: z7.enum(["prometheus", "tempo", "otel-http"]),
+      baseUrl: z7.string().url(),
+      headers: z7.record(z7.string(), z7.string()).optional()
+    })).default([])
+  }).default({ sources: [] }),
+  source: z7.object({
+    provider: z7.literal("github"),
+    owner: z7.string().min(1),
+    repo: z7.string().min(1),
+    defaultBranch: z7.string().default("main"),
+    root: z7.string().default(".")
+  }),
+  code: z7.object({
+    allowedPaths: z7.array(z7.string()).default([]),
+    validationCommands: z7.array(z7.object({
+      id: z7.string().min(1),
+      label: z7.string().min(1),
+      command: z7.string().min(1),
+      workingDirectory: z7.string().default(".")
+    })).default([])
+  }).default({ allowedPaths: [], validationCommands: [] }),
+  dashboards: z7.object({
+    artifactBucket: z7.string().min(1),
+    artifactPrefix: z7.string().default("studio/dashboards")
+  }),
+  operator: z7.object({
+    instructionsPath: z7.string().default("AGENTS.md"),
+    skillPacks: z7.array(z7.string()).default(["@cognidesk/studio-operator-skills"]),
+    models: z7.array(z7.object({
+      id: z7.string().min(1),
+      label: z7.string().min(1),
+      provider: z7.string().min(1),
+      model: z7.string().min(1),
+      default: z7.boolean().optional()
+    })).default([]),
+    allowedCredentialGrants: z7.array(z7.enum([
+      "github",
+      "package_registry",
+      "telemetry",
+      "artifact_store",
+      "studio_adapter",
+      "backend_service"
+    ])).default([])
+  }).default({
+    instructionsPath: "AGENTS.md",
+    skillPacks: ["@cognidesk/studio-operator-skills"],
+    models: [],
+    allowedCredentialGrants: []
+  })
+});
+var StudioTargetOverlaySchema = z7.object({
+  version: z7.literal(1).optional(),
+  target: z7.object({
+    id: z7.string().min(1).optional(),
+    name: z7.string().min(1).optional(),
+    environment: z7.string().optional()
+  }).optional(),
+  runtime: z7.object({
+    baseUrl: z7.string().url().optional(),
+    apiBasePath: z7.string().optional(),
+    studioAdapterBasePath: z7.string().optional(),
+    serviceAuthHeader: z7.string().optional()
+  }).optional(),
+  telemetry: z7.object({
+    sources: z7.array(z7.object({
+      id: z7.string().min(1),
+      label: z7.string().min(1),
+      kind: z7.enum(["prometheus", "tempo", "otel-http"]),
+      baseUrl: z7.string().url(),
+      headers: z7.record(z7.string(), z7.string()).optional()
+    })).optional()
+  }).optional(),
+  source: z7.object({
+    provider: z7.literal("github").optional(),
+    owner: z7.string().min(1).optional(),
+    repo: z7.string().min(1).optional(),
+    defaultBranch: z7.string().optional(),
+    root: z7.string().optional()
+  }).optional(),
+  code: z7.object({
+    allowedPaths: z7.array(z7.string()).optional(),
+    validationCommands: z7.array(z7.object({
+      id: z7.string().min(1),
+      label: z7.string().min(1),
+      command: z7.string().min(1),
+      workingDirectory: z7.string().default(".")
+    })).optional()
+  }).optional(),
+  dashboards: z7.object({
+    artifactBucket: z7.string().min(1).optional(),
+    artifactPrefix: z7.string().optional()
+  }).optional(),
+  operator: z7.object({
+    instructionsPath: z7.string().optional(),
+    skillPacks: z7.array(z7.string()).optional(),
+    models: z7.array(z7.object({
+      id: z7.string().min(1),
+      label: z7.string().min(1),
+      provider: z7.string().min(1),
+      model: z7.string().min(1),
+      default: z7.boolean().optional()
+    })).optional(),
+    allowedCredentialGrants: z7.array(z7.enum([
+      "github",
+      "package_registry",
+      "telemetry",
+      "artifact_store",
+      "studio_adapter",
+      "backend_service"
+    ])).optional()
+  }).optional()
+});
+function mergeStudioTargetManifest(base, overlay = {}) {
+  return StudioTargetManifestSchema.parse(deepMerge(base, overlay));
+}
+function deepMerge(base, overlay) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value === void 0) continue;
+    const baseValue = result[key];
+    result[key] = isPlainRecord(baseValue) && isPlainRecord(value) ? deepMerge(baseValue, value) : value;
+  }
+  return result;
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 export {
+  StudioActionAudienceSchema,
   StudioAgentIntrospectionSchema,
+  StudioCapabilityAvailabilitySchema,
+  StudioChannelAudienceSchema,
+  StudioChannelBehaviorPolicySchema,
+  StudioChannelCapabilitySchema,
+  StudioChannelConfigurationSchema,
+  StudioChannelFlowActivationSchema,
+  StudioChannelHandoffPolicySchema,
+  StudioChannelOutboundPolicySchema,
+  StudioChannelPolicyDetailSchema,
+  StudioChannelSetConfigurationSchema,
+  StudioConfigurationMutationOperationSchema,
+  StudioConfigurationMutationRequestSchema,
+  StudioConfigurationMutationResultSchema,
+  StudioConfigurationSurfaceSchema,
   StudioConversationSummarySchema,
   StudioDashboardArtifactSchema,
   StudioDashboardDataCapabilitySchema,
@@ -481,8 +786,15 @@ export {
   StudioOperatorClientEventSchema,
   StudioOperatorReasoningEffortSchema,
   StudioOperatorServerEventSchema,
+  StudioOperatorSessionIdSchema,
   StudioOperatorSurfaceSchema,
   StudioPermissionSchema,
+  StudioProviderCoverageScopeSchema,
+  StudioProviderCredentialStatusSchema,
+  StudioProviderDirectionSchema,
+  StudioProviderPackageSummarySchema,
+  StudioProviderReadinessSchema,
+  StudioProviderTrustLevelSchema,
   StudioRoleSchema,
   StudioTargetManifestSchema,
   StudioTargetOverlaySchema,
@@ -495,4 +807,3 @@ export {
   permissionsByRole,
   roleHasPermission
 };
-//# sourceMappingURL=index.js.map