@owlmeans/viable-common 0.0.4

package/src/connect/entrypoints.ts

@@ -0,0 +1,291 @@
+import { body, entrypoint, filter, gate, guard, params, query } from '@owlmeans/entrypoint'
+import type { CommonEntrypoint, CommonEntrypointOptions } from '@owlmeans/entrypoint'
+import { route, RouteMethod, socket } from '@owlmeans/route'
+import { ConverterProjectLlmBodySchema } from '../convert/schemas.js'
+import { connect } from './consts.js'
+import {
+  ConnectAttachBodySchema, ConnectConfirmBodySchema, ConnectConvertCreateBodySchema,
+  ConnectConvertProceedBodySchema, ConnectCreateBodySchema, ConnectInquiryParamsSchema,
+  ConnectJobParamsSchema, ConnectModifyBodySchema, ConnectOpParamsSchema, ConnectOpResultSchema,
+  ConnectPipelineParamsSchema, ConnectPipelineResumeBodySchema, ConnectProjectIdSchema,
+  ConnectProjectLlmBodySchema, ConnectSessionOpenSchema, ConnectSessionParamsSchema,
+  ConnectStoryBodySchema, ConnectStoryParamsSchema, ConnectStoryQuerySchema,
+  ConnectWaitQuerySchema, InquiryAnswerSchema
+} from './schemas.js'
+
+/**
+ * What the platform injects when it mounts the connector routes.
+ *
+ * The names of the guard and the gates belong to the deployment, not to the contract: a connector
+ * API on another platform would guard the same paths with its own vocabulary. Everything else —
+ * paths, methods, schemas, parents — is fixed here so a client cannot address them differently.
+ */
+export interface ConnectEntrypointOptions {
+  /** The guard alias every connector route carries. */
+  guard: string
+  /** The gate alias and parameters that decide project ownership. */
+  gate?: { alias: string, params: string[] }
+  /**
+   * The gate that decides whether the caller may use the local-LLM mode.
+   *
+   * Applied to the two routes that can turn it on — opening a delegated session and pinning a
+   * project to it. Everything else is free: `cloud` is the default and the platform writes it
+   * back by itself when a plan lapses.
+   */
+  localLlm?: { alias: string, params: string[] }
+  /** The parent of the socket route — the platform's own websocket base. */
+  updateBase: string
+  /** Path prefix; defaults to `/connect`. */
+  path?: string
+}
+
+/**
+ * Declare the connector's HTTP and socket surface.
+ *
+ * One list, spread into the platform's own entrypoints. Handlers are elevated onto these aliases
+ * server-side and onto client entrypoints in the SDK — the same declarations both times, which is
+ * what makes a path or a schema impossible to get wrong on one side only.
+ */
+export const connectEntrypoints = (opts: ConnectEntrypointOptions): CommonEntrypoint[] => {
+  const prefix = opts.path ?? '/connect'
+  const ownership = opts.gate != null
+    ? guard(opts.guard, gate(opts.gate.alias, opts.gate.params))
+    : guard(opts.guard)
+  const paid: CommonEntrypointOptions | undefined = opts.localLlm != null
+    ? gate(opts.localLlm.alias, opts.localLlm.params)
+    : undefined
+
+  return [
+    entrypoint(route(connect.base, prefix), ownership),
+
+    entrypoint(route(connect.capabilities, '/capabilities', {
+      parent: connect.base, method: RouteMethod.GET
+    })),
+
+    // --- session ---------------------------------------------------------------------------
+    entrypoint(
+      route(connect.session.open, '/session', { parent: connect.base, method: RouteMethod.POST }),
+      filter(body(ConnectSessionOpenSchema))
+    ),
+    entrypoint(
+      route(connect.session.openDelegated, '/session/delegated', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(body(ConnectSessionOpenSchema), paid)
+    ),
+    entrypoint(
+      route(connect.session.get, '/session/:sessionId', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectSessionParamsSchema))
+    ),
+    entrypoint(
+      route(connect.session.heartbeat, '/session/:sessionId/heartbeat', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectSessionParamsSchema))
+    ),
+    entrypoint(
+      route(connect.session.close, '/session/:sessionId/close', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectSessionParamsSchema))
+    ),
+    entrypoint(
+      route(connect.session.socket, '/connect/:sessionId', socket(opts.updateBase)),
+      filter(params(ConnectSessionParamsSchema))
+    ),
+
+    // --- operations ------------------------------------------------------------------------
+    entrypoint(
+      route(connect.op.pull, '/session/:sessionId/ops', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectSessionParamsSchema, query(ConnectWaitQuerySchema)))
+    ),
+    entrypoint(
+      route(connect.op.submit, '/session/:sessionId/ops/:opId', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectOpParamsSchema, body(ConnectOpResultSchema)))
+    ),
+
+    // --- project ---------------------------------------------------------------------------
+    entrypoint(
+      route(connect.project.create, '/project', { parent: connect.base, method: RouteMethod.POST }),
+      filter(body(ConnectCreateBodySchema))
+    ),
+    entrypoint(route(connect.project.list, '/project', {
+      parent: connect.base, method: RouteMethod.GET
+    })),
+    entrypoint(
+      route(connect.project.attach, '/project/attach', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(body(ConnectAttachBodySchema))
+    ),
+    entrypoint(
+      route(connect.project.confirm, '/project/:id/confirm', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectProjectIdSchema, body(ConnectConfirmBodySchema)))
+    ),
+    entrypoint(
+      route(connect.project.status, '/project/:id/status', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+    entrypoint(
+      route(connect.project.reinit, '/project/:id/reinit', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+    entrypoint(
+      route(connect.project.modify, '/project/:id/modify', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectProjectIdSchema, body(ConnectModifyBodySchema)))
+    ),
+    entrypoint(
+      route(connect.project.settings, '/project/:id/settings', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+    entrypoint(
+      route(connect.project.llm, '/project/:id/llm', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectProjectIdSchema, body(ConnectProjectLlmBodySchema)), paid)
+    ),
+    entrypoint(
+      route(connect.project.job, '/project/:id/job/:jobId', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectJobParamsSchema, query(ConnectWaitQuerySchema)))
+    ),
+
+    // --- stories ---------------------------------------------------------------------------
+    entrypoint(
+      route(connect.story.list, '/story/:id', { parent: connect.base, method: RouteMethod.GET }),
+      filter(params(ConnectProjectIdSchema, query(ConnectStoryQuerySchema)))
+    ),
+    entrypoint(
+      route(connect.story.create, '/story/:id', { parent: connect.base, method: RouteMethod.POST }),
+      filter(params(ConnectProjectIdSchema, body(ConnectStoryBodySchema)))
+    ),
+    entrypoint(
+      route(connect.story.get, '/story/:id/:storyId', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectStoryParamsSchema))
+    ),
+    entrypoint(
+      route(connect.story.update, '/story/:id/:storyId', {
+        parent: connect.base, method: RouteMethod.PUT
+      }),
+      filter(params(ConnectStoryParamsSchema, body(ConnectStoryBodySchema)))
+    ),
+    entrypoint(
+      route(connect.story.delete, '/story/:id/:storyId', {
+        parent: connect.base, method: RouteMethod.DELETE
+      }),
+      filter(params(ConnectStoryParamsSchema))
+    ),
+    entrypoint(
+      route(connect.story.develop, '/story/:id/:storyId/develop', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectStoryParamsSchema))
+    ),
+
+    // --- generated files -------------------------------------------------------------------
+    entrypoint(
+      route(connect.files.list, '/project/:id/files', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+
+    entrypoint(
+      route(connect.project.converterLlm, '/project/:id/converter-llm', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      // No paid gate, unlike `project.llm`: delegated inference is the DEFAULT for a conversion,
+      // not an experimental capability. A conversion reads somebody else's whole repository, and
+      // handing those calls to the parent agent is what makes it affordable at all.
+      filter(params(ConnectProjectIdSchema, body(ConverterProjectLlmBodySchema)))
+    ),
+
+    // --- conversion ------------------------------------------------------------------------
+    entrypoint(
+      route(connect.convert.create, '/convert', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(body(ConnectConvertCreateBodySchema))
+    ),
+    entrypoint(
+      route(connect.convert.check, '/convert/:id/check', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+    entrypoint(
+      route(connect.convert.start, '/convert/:id/start', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+    entrypoint(
+      route(connect.convert.proceed, '/convert/:id/proceed', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectProjectIdSchema, body(ConnectConvertProceedBodySchema)))
+    ),
+    entrypoint(
+      route(connect.convert.cancel, '/convert/:id/cancel', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+    entrypoint(
+      route(connect.convert.status, '/convert/:id', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+    entrypoint(
+      route(connect.convert.purge, '/convert/:id/purge', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectProjectIdSchema))
+    ),
+
+    // --- inquiries -------------------------------------------------------------------------
+    // The fallback answer path: a connector answers through its own op id while it holds the
+    // question, but a run that parked while nobody was attached has no op to answer, and the
+    // question is then reachable only by its own id.
+    entrypoint(
+      route(connect.inquiry.answer, '/project/:id/inquiry/:inquiryId', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectInquiryParamsSchema, body(InquiryAnswerSchema)))
+    ),
+
+    // --- pipelines -------------------------------------------------------------------------
+    entrypoint(
+      route(connect.pipeline.state, '/pipeline/:id/:runId', {
+        parent: connect.base, method: RouteMethod.GET
+      }),
+      filter(params(ConnectPipelineParamsSchema))
+    ),
+    entrypoint(
+      route(connect.pipeline.resume, '/pipeline/:id/:runId/resume', {
+        parent: connect.base, method: RouteMethod.POST
+      }),
+      filter(params(ConnectPipelineParamsSchema, body(ConnectPipelineResumeBodySchema)))
+    ),
+  ]
+}

package/src/connect/errors.ts

@@ -0,0 +1,91 @@
+import { ResilientError } from '@owlmeans/error'
+
+export class ConnectError extends ResilientError {
+  public static override typeName = `ViableConnect${ResilientError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(ConnectError.typeName, `viable-connect:${message}`)
+  }
+}
+
+/** No session with that id, or it belongs to another profile. */
+export class ConnectSessionNotFound extends ConnectError {
+  public static override typeName = `SessionNotFound${ConnectError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(`session-not-found:${message}`)
+    this.type = ConnectSessionNotFound.typeName
+  }
+}
+
+/**
+ * Nothing is attached to the project, and the operation needs a connector.
+ *
+ * FATAL by registration on the agent side: a run whose executor has gone away must stop at once
+ * rather than spend a retry ladder — the library retries a template write three times, the coder
+ * retries eight, and a model call retries eight inside that, so an unrecognised failure here costs
+ * minutes of nothing and a project lock held throughout. The step fails as an OUTCOME, the run row
+ * records where it stopped, and `pipeline.resume` picks it up when a connector returns.
+ */
+export class ConnectSessionGone extends ConnectError {
+  public static override typeName = `SessionGone${ConnectError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(`session-gone:${message}`)
+    this.type = ConnectSessionGone.typeName
+  }
+}
+
+/** The connector did not answer within the command's own deadline. Retryable. */
+export class ConnectOpTimeout extends ConnectError {
+  public static override typeName = `OpTimeout${ConnectError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(`op-timeout:${message}`)
+    this.type = ConnectOpTimeout.typeName
+  }
+}
+
+/** The connector executed the operation and refused it — a path outside the project, say. */
+export class ConnectOpRefused extends ConnectError {
+  public static override typeName = `OpRefused${ConnectError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(`op-refused:${message}`)
+    this.type = ConnectOpRefused.typeName
+  }
+}
+
+/**
+ * The operation is meaningless for a local slot.
+ *
+ * Sandbox lifecycle, production, preview watching and remote git all address infrastructure a
+ * local target does not have. Refusing by name is what keeps a connector's tool list honest: the
+ * tool is hidden where it cannot work, and the API says so if one is called anyway.
+ */
+export class LocalSlotUnsupported extends ConnectError {
+  public static override typeName = `LocalUnsupported${ConnectError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(`local-unsupported:${message}`)
+    this.type = LocalSlotUnsupported.typeName
+  }
+}
+
+/** The op id is unknown, already answered, or belongs to another session. */
+export class ConnectOpUnknown extends ConnectError {
+  public static override typeName = `OpUnknown${ConnectError.typeName}`
+
+  constructor(message: string = 'error') {
+    super(`op-unknown:${message}`)
+    this.type = ConnectOpUnknown.typeName
+  }
+}
+
+ResilientError.registerErrorClass(ConnectError)
+ResilientError.registerErrorClass(ConnectSessionNotFound)
+ResilientError.registerErrorClass(ConnectSessionGone)
+ResilientError.registerErrorClass(ConnectOpTimeout)
+ResilientError.registerErrorClass(ConnectOpRefused)
+ResilientError.registerErrorClass(LocalSlotUnsupported)
+ResilientError.registerErrorClass(ConnectOpUnknown)

package/src/connect/index.ts

@@ -0,0 +1,7 @@
+export * from './consts.js'
+export * from './schemas.js'
+export * from './errors.js'
+export * from './entrypoints.js'
+export * from './references.js'
+export type * from './types.js'
+export type * from './ops.js'

package/src/connect/ops.ts

@@ -0,0 +1,208 @@
+import type { SlotCommandPayload } from '../slot/index.js'
+import type {
+  ConnectInquiryKind, ConnectOpErrorKind, ConnectOpKind, ModelTaskMode, ModelTaskResultKind,
+  ModelTaskRole, ModelTier
+} from './consts.js'
+import type { ConnectServices } from './types.js'
+
+/**
+ * One thing the platform asks a connector to do.
+ *
+ * Operations are addressed to a PROJECT, not to a session: a connector that restarts mid-run
+ * re-attaches and is handed whatever is still pending, so an MCP server dying does not kill a
+ * pipeline that is minutes into its work. `sessionId` records which session it was published to,
+ * for tracing and for the redelivery counter — never for routing a result back.
+ */
+export interface ConnectOp {
+  id: string
+  projectId: string
+  sessionId: string
+  kind: ConnectOpKind
+  payload: SlotCommandPayload | ModelTask | ConfigurePayload | InquiryPayload
+  createdAt: string
+  /** When the asker stops waiting. A connector past this may skip the work and say so. */
+  deadlineAt: string
+  /** How many times this op has been delivered. > 1 means a connector reconnected. */
+  attempt: number
+  deliveredAt?: string
+}
+
+/**
+ * The answer to exactly one operation.
+ *
+ * `ok: false` with `kind: 'malformed'` is a RETRYABLE outcome — the platform asks again, with the
+ * problem quoted back. `'unavailable'` says the connector cannot do this at all and the run should
+ * fail rather than spin.
+ */
+export interface ConnectOpResult {
+  opId: string
+  sessionId: string
+  ok: boolean
+  value?: unknown
+  error?: ConnectOpError
+}
+
+export interface ConnectOpError {
+  type: string
+  message: string
+  kind?: ConnectOpErrorKind
+}
+
+/**
+ * The configuration a local target needs, as file CONTENT rather than as keys.
+ *
+ * The platform composes it — it is the only side that knows the OIDC client, its secret and the
+ * redirect URIs — and the connector writes it into the managed block of each named file, leaving
+ * every line the user added alone. `probe` names the services the platform wants to know about
+ * before it asks for a database migration or a boot check.
+ */
+export interface ConfigurePayload {
+  files: ConfigureFile[]
+  probe: Array<keyof ConnectServices>
+}
+
+export interface ConfigureFile {
+  /** Target-root-relative, e.g. `.env` or `sources/web/.env`. */
+  path: string
+  /** The managed block's content. Written between the connector's own markers. */
+  content: string
+}
+
+export interface ConfigureResult {
+  written: string[]
+  /**
+   * Keys the target still needs and the user must supply — a local database URL, say.
+   *
+   * Read exactly like the publisher's configure acknowledgement: a key with an EMPTY value counts
+   * as missing, because a push that ran before a secret existed leaves one behind.
+   */
+  missing: string[]
+  services: ConnectServices
+}
+
+/**
+ * One model call, handed to the parent agent.
+ *
+ * It carries everything a fresh subagent needs and nothing it does not: the persona as a system
+ * prompt, the conversation so far, and the shape the answer must take. There is no platform
+ * vocabulary in it — no pipeline, no step, no internal role semantics beyond a name and a tier —
+ * because it is read by a model the platform does not own.
+ */
+export interface ModelTask {
+  id: string
+  projectId: string
+  /** The job the call belongs to, so a parent can say what it is working on. */
+  jobId?: string
+  /** The platform role that asked. Informational; the tier is what decides the model. */
+  role: string
+  tier: ModelTier
+  /** Which attempt this is. > 0 means a previous answer was refused; `feedback` says why. */
+  attempt: number
+  mode: ModelTaskMode
+  system?: string
+  messages: ModelTaskMessage[]
+  /** `Tools` mode: what the subagent may call. JSON Schema per tool. */
+  tools?: ModelTaskTool[]
+  /** `Tools` mode: force one tool, or leave the choice open. */
+  toolChoice?: ModelTaskToolChoice
+  /** `Json` mode: the schema the single returned object must satisfy. */
+  outputSchema?: Record<string, unknown>
+  /** A soft cap, stated so a parent can size its own call. */
+  maxOutputChars?: number
+  /** Present on a retry: what was wrong with the previous answer. */
+  feedback?: string
+  expiresAt: string
+}
+
+export interface ModelTaskMessage {
+  role: ModelTaskRole
+  content: string
+  /** Assistant messages that called tools. */
+  toolCalls?: ModelTaskToolCall[]
+  /** Tool messages answer one call. */
+  toolCallId?: string
+  /** Tool messages name the tool they answer. */
+  name?: string
+}
+
+export interface ModelTaskTool {
+  name: string
+  description?: string
+  /** JSON Schema for the tool's arguments. */
+  parameters: Record<string, unknown>
+}
+
+export type ModelTaskToolChoice = 'auto' | 'none' | { name: string }
+
+export interface ModelTaskToolCall {
+  id?: string
+  name: string
+  args: Record<string, unknown>
+}
+
+/** What the parent's subagent produced. */
+export interface ModelTaskResult {
+  taskId: string
+  kind: ModelTaskResultKind
+  text?: string
+  json?: unknown
+  toolCalls?: ModelTaskToolCall[]
+  /** Why the parent could not answer. Treated as a malformed answer and retried. */
+  error?: string
+  /** What the parent spent. Recorded for the trace; it costs the platform nothing. */
+  usage?: ModelTaskUsage
+  /** What the parent actually ran. Display only. */
+  model?: string
+}
+
+export interface ModelTaskUsage {
+  inputTokens?: number
+  outputTokens?: number
+}
+
+/** One option a {@link ConnectInquiryKind.Choice} question offers. */
+export interface ConnectInquiryOption {
+  value: string
+  label: string
+  description?: string
+}
+
+/**
+ * One question put to the person the connector is working for.
+ *
+ * It carries where it came from — the job, the run and the step — because an answer is recorded
+ * against the run that asked and re-read when that run resumes. `expiresAt` is what makes an
+ * unanswered question fail its step instead of parking a project lock forever.
+ */
+export interface InquiryPayload {
+  id: string
+  projectId: string
+  jobId?: string
+  runId?: string
+  /** The pipeline step that asked, so a resumed run can match the answer to the place it belongs. */
+  step?: string
+  kind: ConnectInquiryKind
+  question: string
+  /** What the asker already knows, so the person is not asked to go and find it out. */
+  context?: string
+  options?: ConnectInquiryOption[]
+  multiple?: boolean
+  /** Whether a choice question also accepts text the options do not cover. */
+  allowText?: boolean
+  /** What the asker will assume if nobody answers. Recorded as an assumption when it is used. */
+  default?: string | string[]
+  expiresAt: string
+}
+
+/**
+ * The answer to one question.
+ *
+ * `declined` is a real answer and not an absence: it says a person saw the question and chose not
+ * to decide, which the asker records as an assumption rather than waiting out the timeout.
+ */
+export interface InquiryAnswerPayload {
+  inquiryId: string
+  value?: string | string[]
+  text?: string
+  declined?: boolean
+}

package/src/connect/references.ts

@@ -0,0 +1,89 @@
+import { entrypointRef } from '@owlmeans/entrypoint'
+import { connect } from './consts.js'
+import type { ConnectOp, ConnectOpResult } from './ops.js'
+import type { ConverterProjectLlmBody } from '../convert/index.js'
+import type {
+  ConnectAttachBody, ConnectCapabilitiesView, ConnectConfirmBody, ConnectCreateBody, ConnectJob,
+  ConnectConvertCreateBody, ConnectConvertProceedBody, ConnectInquiryAnswerBody, ConnectJobParams,
+  ConnectModifyBody, ConnectOpSubmission, ConnectPipelineParams, ConnectPipelineResumeBody,
+  ConnectPipelineState, ConnectProjectLlmBody, ConnectProjectSettings, ConnectProjectStatus,
+  ConnectProjectSummary, ConnectSessionOpen, ConnectSessionParams, ConnectSessionView,
+  ConnectStoryBody, ConnectStoryDeletion, ConnectStoryItem, ConnectStoryList, ConnectStoryMutation,
+  ConnectStoryQuery, ConnectWaitQuery, ConversionStatusView, ConvertCheck,
+} from './types.js'
+
+/**
+ * Typed references for adapter packages that address the connector dynamically.  Applications
+ * export protocol objects instead; an adapter may use this compact form because it never exposes
+ * aliases to UI or domain code.
+ */
+export const connectRef = {
+  capabilities: entrypointRef<{}, ConnectCapabilitiesView>(connect.capabilities),
+  session: {
+    open: entrypointRef<{ body: ConnectSessionOpen }, ConnectSessionView>(connect.session.open),
+    openDelegated: entrypointRef<{ body: ConnectSessionOpen }, ConnectSessionView>(connect.session.openDelegated),
+    get: entrypointRef<{ params: ConnectSessionParams }, ConnectSessionView>(connect.session.get),
+    heartbeat: entrypointRef<{ params: ConnectSessionParams }, ConnectSessionView>(connect.session.heartbeat),
+    close: entrypointRef<{ params: ConnectSessionParams }, ConnectSessionView>(connect.session.close),
+  },
+  op: {
+    pull: entrypointRef<{ params: ConnectSessionParams, query: ConnectWaitQuery }, ConnectOp[]>(connect.op.pull),
+    submit: entrypointRef<{
+      params: { sessionId: string, opId: string }, body: ConnectOpResult
+    }, ConnectOpSubmission>(connect.op.submit),
+  },
+  project: {
+    create: entrypointRef<{ body: ConnectCreateBody }, ConnectJob>(connect.project.create),
+    confirm: entrypointRef<{ params: { id: string }, body: ConnectConfirmBody }, ConnectJob>(connect.project.confirm),
+    list: entrypointRef<{}, ConnectProjectSummary[]>(connect.project.list),
+    status: entrypointRef<{ params: { id: string } }, ConnectProjectStatus>(connect.project.status),
+    attach: entrypointRef<{ body: ConnectAttachBody }, ConnectProjectStatus>(connect.project.attach),
+    reinit: entrypointRef<{ params: { id: string } }, ConnectJob>(connect.project.reinit),
+    modify: entrypointRef<{ params: { id: string }, body: ConnectModifyBody }, ConnectJob>(connect.project.modify),
+    settings: entrypointRef<{ params: { id: string } }, ConnectProjectSettings>(connect.project.settings),
+    llm: entrypointRef<{
+      params: { id: string }, body: ConnectProjectLlmBody
+    }, ConnectProjectSettings>(connect.project.llm),
+    converterLlm: entrypointRef<{
+      params: { id: string }, body: ConverterProjectLlmBody
+    }, ConnectProjectSettings>(connect.project.converterLlm),
+    job: entrypointRef<{ params: ConnectJobParams, query: ConnectWaitQuery }, ConnectJob>(connect.project.job),
+  },
+  convert: {
+    create: entrypointRef<{ body: ConnectConvertCreateBody }, ConnectJob>(connect.convert.create),
+    check: entrypointRef<{ params: { id: string } }, ConvertCheck>(connect.convert.check),
+    start: entrypointRef<{ params: { id: string } }, ConnectJob>(connect.convert.start),
+    proceed: entrypointRef<{
+      params: { id: string }, body: ConnectConvertProceedBody
+    }, ConnectJob>(connect.convert.proceed),
+    cancel: entrypointRef<{ params: { id: string } }, ConnectJob>(connect.convert.cancel),
+    status: entrypointRef<{
+      params: { id: string }
+    }, ConversionStatusView>(connect.convert.status),
+    purge: entrypointRef<{ params: { id: string } }, ConnectJob>(connect.convert.purge),
+  },
+  inquiry: {
+    answer: entrypointRef<{
+      params: { id: string, inquiryId: string }, body: ConnectInquiryAnswerBody
+    }, unknown>(connect.inquiry.answer),
+  },
+  story: {
+    list: entrypointRef<{ params: { id: string }, query: ConnectStoryQuery }, ConnectStoryList>(connect.story.list),
+    get: entrypointRef<{ params: { id: string, storyId: string } }, ConnectStoryItem>(connect.story.get),
+    create: entrypointRef<{ params: { id: string }, body: ConnectStoryBody }, ConnectStoryMutation>(connect.story.create),
+    update: entrypointRef<{
+      params: { id: string, storyId: string }, body: ConnectStoryBody
+    }, ConnectStoryMutation>(connect.story.update),
+    delete: entrypointRef<{ params: { id: string, storyId: string } }, ConnectStoryDeletion>(connect.story.delete),
+    develop: entrypointRef<{ params: { id: string, storyId: string } }, ConnectJob>(connect.story.develop),
+  },
+  files: {
+    list: entrypointRef<{ params: { id: string } }, string[]>(connect.files.list),
+  },
+  pipeline: {
+    state: entrypointRef<{ params: ConnectPipelineParams }, ConnectPipelineState>(connect.pipeline.state),
+    resume: entrypointRef<{
+      params: ConnectPipelineParams, body: ConnectPipelineResumeBody
+    }, ConnectJob>(connect.pipeline.resume),
+  },
+}