@owlmeans/viable-common 0.0.5 → 0.0.7

package/src/connect/entrypoints.ts

@@ -1,17 +1,20 @@
-import { body, entrypoint, filter, gate, guard, params, query } from '@owlmeans/entrypoint'
-import type { CommonEntrypoint, CommonEntrypointOptions } from '@owlmeans/entrypoint'
+import { contract, openProtocol, protocol, typed } from '@owlmeans/entrypoint'
+import type { EntrypointProtocolDeclaration } 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,
+  ConnectAttachBodySchema, ConnectConfirmBodySchema, ConnectCreateBodySchema,
   ConnectJobParamsSchema, ConnectModifyBodySchema, ConnectOpParamsSchema, ConnectOpResultSchema,
   ConnectPipelineParamsSchema, ConnectPipelineResumeBodySchema, ConnectProjectIdSchema,
   ConnectProjectLlmBodySchema, ConnectSessionOpenSchema, ConnectSessionParamsSchema,
-  ConnectStoryBodySchema, ConnectStoryParamsSchema, ConnectStoryQuerySchema,
-  ConnectWaitQuerySchema, InquiryAnswerSchema
+  ConnectStoryBodySchema, ConnectStoryParamsSchema, ConnectStoryQuerySchema, ConnectWaitQuerySchema
 } from './schemas.js'
+import type {
+  ConnectAttachBody, ConnectConfirmBody, ConnectCreateBody, ConnectJobParams, ConnectModifyBody,
+  ConnectPipelineParams, ConnectPipelineResumeBody, ConnectProjectLlmBody, ConnectSessionOpen,
+  ConnectSessionParams, ConnectStoryBody, ConnectStoryQuery, ConnectWaitQuery,
+} from './types.js'
+import type { ConnectOpResult } from './ops.js'
 
 /**
  * What the platform injects when it mounts the connector routes.
@@ -42,250 +45,177 @@ export interface ConnectEntrypointOptions {
 /**
  * Declare the connector's HTTP and socket surface.
  *
- * One list, spread into the platform's own entrypoints. Handlers are elevated onto these aliases
+ * One list, spread into the platform's own entrypoints. Handlers are bound to these protocols
  * 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[] => {
+export const connectEntrypoints = (opts: ConnectEntrypointOptions): EntrypointProtocolDeclaration[] => {
   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)
+    ? { guards: opts.guard, gate: opts.gate }
+    : { guards: opts.guard }
+  const paid = opts.localLlm != null
+    ? { gate: opts.localLlm }
     : undefined
 
   return [
-    entrypoint(route(connect.base, prefix), ownership),
+    openProtocol(route(connect.base, prefix), ownership),
 
-    entrypoint(route(connect.capabilities, '/capabilities', {
+    openProtocol(route(connect.capabilities, '/capabilities', {
       parent: connect.base, method: RouteMethod.GET
     })),
 
     // --- session ---------------------------------------------------------------------------
-    entrypoint(
+    protocol(
       route(connect.session.open, '/session', { parent: connect.base, method: RouteMethod.POST }),
-      filter(body(ConnectSessionOpenSchema))
+      contract.request({ body: typed<ConnectSessionOpen>(ConnectSessionOpenSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.session.openDelegated, '/session/delegated', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(body(ConnectSessionOpenSchema), paid)
+      contract.request({ body: typed<ConnectSessionOpen>(ConnectSessionOpenSchema) }, typed()), paid
     ),
-    entrypoint(
+    protocol(
       route(connect.session.get, '/session/:sessionId', {
         parent: connect.base, method: RouteMethod.GET
       }),
-      filter(params(ConnectSessionParamsSchema))
+      contract.request({ params: typed<ConnectSessionParams>(ConnectSessionParamsSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.session.heartbeat, '/session/:sessionId/heartbeat', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(params(ConnectSessionParamsSchema))
+      contract.request({ params: typed<ConnectSessionParams>(ConnectSessionParamsSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.session.close, '/session/:sessionId/close', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(params(ConnectSessionParamsSchema))
+      contract.request({ params: typed<ConnectSessionParams>(ConnectSessionParamsSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.session.socket, '/connect/:sessionId', socket(opts.updateBase)),
-      filter(params(ConnectSessionParamsSchema))
+      contract.request({ params: typed<ConnectSessionParams>(ConnectSessionParamsSchema) }, typed())
     ),
 
     // --- operations ------------------------------------------------------------------------
-    entrypoint(
+    protocol(
       route(connect.op.pull, '/session/:sessionId/ops', {
         parent: connect.base, method: RouteMethod.GET
       }),
-      filter(params(ConnectSessionParamsSchema, query(ConnectWaitQuerySchema)))
+      contract.request({ params: typed<ConnectSessionParams>(ConnectSessionParamsSchema), query: typed<ConnectWaitQuery>(ConnectWaitQuerySchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.op.submit, '/session/:sessionId/ops/:opId', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(params(ConnectOpParamsSchema, body(ConnectOpResultSchema)))
+      contract.request({ params: typed<{ sessionId: string, opId: string }>(ConnectOpParamsSchema), body: typed<ConnectOpResult>(ConnectOpResultSchema) }, typed())
     ),
 
     // --- project ---------------------------------------------------------------------------
-    entrypoint(
+    protocol(
       route(connect.project.create, '/project', { parent: connect.base, method: RouteMethod.POST }),
-      filter(body(ConnectCreateBodySchema))
+      contract.request({ body: typed<ConnectCreateBody>(ConnectCreateBodySchema) }, typed())
     ),
-    entrypoint(route(connect.project.list, '/project', {
+    openProtocol(route(connect.project.list, '/project', {
       parent: connect.base, method: RouteMethod.GET
     })),
-    entrypoint(
+    protocol(
       route(connect.project.attach, '/project/attach', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(body(ConnectAttachBodySchema))
+      contract.request({ body: typed<ConnectAttachBody>(ConnectAttachBodySchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.project.confirm, '/project/:id/confirm', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(params(ConnectProjectIdSchema, body(ConnectConfirmBodySchema)))
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectConfirmBody>(ConnectConfirmBodySchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.project.status, '/project/:id/status', {
         parent: connect.base, method: RouteMethod.GET
       }),
-      filter(params(ConnectProjectIdSchema))
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.project.reinit, '/project/:id/reinit', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(params(ConnectProjectIdSchema))
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.project.modify, '/project/:id/modify', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(params(ConnectProjectIdSchema, body(ConnectModifyBodySchema)))
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectModifyBody>(ConnectModifyBodySchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.project.settings, '/project/:id/settings', {
         parent: connect.base, method: RouteMethod.GET
       }),
-      filter(params(ConnectProjectIdSchema))
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.project.llm, '/project/:id/llm', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(params(ConnectProjectIdSchema, body(ConnectProjectLlmBodySchema)), paid)
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectProjectLlmBody>(ConnectProjectLlmBodySchema) }, typed()), paid
     ),
-    entrypoint(
+    protocol(
       route(connect.project.job, '/project/:id/job/:jobId', {
         parent: connect.base, method: RouteMethod.GET
       }),
-      filter(params(ConnectJobParamsSchema, query(ConnectWaitQuerySchema)))
+      contract.request({ params: typed<ConnectJobParams>(ConnectJobParamsSchema), query: typed<ConnectWaitQuery>(ConnectWaitQuerySchema) }, typed())
     ),
 
     // --- stories ---------------------------------------------------------------------------
-    entrypoint(
+    protocol(
       route(connect.story.list, '/story/:id', { parent: connect.base, method: RouteMethod.GET }),
-      filter(params(ConnectProjectIdSchema, query(ConnectStoryQuerySchema)))
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), query: typed<ConnectStoryQuery>(ConnectStoryQuerySchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.story.create, '/story/:id', { parent: connect.base, method: RouteMethod.POST }),
-      filter(params(ConnectProjectIdSchema, body(ConnectStoryBodySchema)))
+      contract.request({ params: typed<{ id: string }>(ConnectProjectIdSchema), body: typed<ConnectStoryBody>(ConnectStoryBodySchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.story.get, '/story/:id/:storyId', {
         parent: connect.base, method: RouteMethod.GET
       }),
-      filter(params(ConnectStoryParamsSchema))
+      contract.request({ params: typed<{ id: string, storyId: string }>(ConnectStoryParamsSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.story.update, '/story/:id/:storyId', {
         parent: connect.base, method: RouteMethod.PUT
       }),
-      filter(params(ConnectStoryParamsSchema, body(ConnectStoryBodySchema)))
+      contract.request({ params: typed<{ id: string, storyId: string }>(ConnectStoryParamsSchema), body: typed<ConnectStoryBody>(ConnectStoryBodySchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.story.delete, '/story/:id/:storyId', {
         parent: connect.base, method: RouteMethod.DELETE
       }),
-      filter(params(ConnectStoryParamsSchema))
+      contract.request({ params: typed<{ id: string, storyId: string }>(ConnectStoryParamsSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       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)))
+      contract.request({ params: typed<{ id: string, storyId: string }>(ConnectStoryParamsSchema) }, typed())
     ),
 
     // --- pipelines -------------------------------------------------------------------------
-    entrypoint(
+    protocol(
       route(connect.pipeline.state, '/pipeline/:id/:runId', {
         parent: connect.base, method: RouteMethod.GET
       }),
-      filter(params(ConnectPipelineParamsSchema))
+      contract.request({ params: typed<ConnectPipelineParams>(ConnectPipelineParamsSchema) }, typed())
     ),
-    entrypoint(
+    protocol(
       route(connect.pipeline.resume, '/pipeline/:id/:runId/resume', {
         parent: connect.base, method: RouteMethod.POST
       }),
-      filter(params(ConnectPipelineParamsSchema, body(ConnectPipelineResumeBodySchema)))
+      contract.request({ params: typed<ConnectPipelineParams>(ConnectPipelineParamsSchema), body: typed<ConnectPipelineResumeBody>(ConnectPipelineResumeBodySchema) }, typed())
     ),
   ]
 }

package/src/connect/ops.ts

@@ -1,7 +1,6 @@
 import type { SlotCommandPayload } from '../slot/index.js'
 import type {
-  ConnectInquiryKind, ConnectOpErrorKind, ConnectOpKind, ModelTaskMode, ModelTaskResultKind,
-  ModelTaskRole, ModelTier
+  ConnectOpErrorKind, ConnectOpKind, ModelTaskMode, ModelTaskResultKind, ModelTaskRole, ModelTier
 } from './consts.js'
 import type { ConnectServices } from './types.js'
 
@@ -18,7 +17,7 @@ export interface ConnectOp {
   projectId: string
   sessionId: string
   kind: ConnectOpKind
-  payload: SlotCommandPayload | ModelTask | ConfigurePayload | InquiryPayload
+  payload: SlotCommandPayload | ModelTask | ConfigurePayload
   createdAt: string
   /** When the asker stops waiting. A connector past this may skip the work and say so. */
   deadlineAt: string
@@ -159,50 +158,3 @@ 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

@@ -1,23 +1,71 @@
 import { entrypointRef } from '@owlmeans/entrypoint'
+import type { RegisteredEntrypoint, RequestShape } from '@owlmeans/entrypoint'
+import type { EntrypointReference } from '@owlmeans/context'
 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,
+  ConnectJobParams, ConnectModifyBody, ConnectOpSubmission, ConnectPipelineParams,
+  ConnectPipelineResumeBody, ConnectPipelineState, ConnectProjectLlmBody, ConnectProjectSettings,
+  ConnectProjectStatus, ConnectProjectSummary, ConnectSessionOpen, ConnectSessionParams,
+  ConnectSessionView, ConnectStoryBody, ConnectStoryDeletion, ConnectStoryItem, ConnectStoryList,
+  ConnectStoryMutation, ConnectStoryQuery, ConnectWaitQuery,
 } from './types.js'
 
+type ConnectReference<Request extends RequestShape, Response> =
+  EntrypointReference<RegisteredEntrypoint<Request, Response>>
+
+export interface ConnectReferences {
+  capabilities: ConnectReference<{}, ConnectCapabilitiesView>
+  session: {
+    open: ConnectReference<{ body: ConnectSessionOpen }, ConnectSessionView>
+    openDelegated: ConnectReference<{ body: ConnectSessionOpen }, ConnectSessionView>
+    get: ConnectReference<{ params: ConnectSessionParams }, ConnectSessionView>
+    heartbeat: ConnectReference<{ params: ConnectSessionParams }, ConnectSessionView>
+    close: ConnectReference<{ params: ConnectSessionParams }, ConnectSessionView>
+  }
+  op: {
+    pull: ConnectReference<{ params: ConnectSessionParams, query: ConnectWaitQuery }, ConnectOp[]>
+    submit: ConnectReference<{
+      params: { sessionId: string, opId: string }, body: ConnectOpResult
+    }, ConnectOpSubmission>
+  }
+  project: {
+    create: ConnectReference<{ body: ConnectCreateBody }, ConnectJob>
+    confirm: ConnectReference<{ params: { id: string }, body: ConnectConfirmBody }, ConnectJob>
+    list: ConnectReference<{}, ConnectProjectSummary[]>
+    status: ConnectReference<{ params: { id: string } }, ConnectProjectStatus>
+    attach: ConnectReference<{ body: ConnectAttachBody }, ConnectProjectStatus>
+    reinit: ConnectReference<{ params: { id: string } }, ConnectJob>
+    modify: ConnectReference<{ params: { id: string }, body: ConnectModifyBody }, ConnectJob>
+    settings: ConnectReference<{ params: { id: string } }, ConnectProjectSettings>
+    llm: ConnectReference<{ params: { id: string }, body: ConnectProjectLlmBody }, ConnectProjectSettings>
+    job: ConnectReference<{ params: ConnectJobParams, query: ConnectWaitQuery }, ConnectJob>
+  }
+  story: {
+    list: ConnectReference<{ params: { id: string }, query: ConnectStoryQuery }, ConnectStoryList>
+    get: ConnectReference<{ params: { id: string, storyId: string } }, ConnectStoryItem>
+    create: ConnectReference<{ params: { id: string }, body: ConnectStoryBody }, ConnectStoryMutation>
+    update: ConnectReference<{
+      params: { id: string, storyId: string }, body: ConnectStoryBody
+    }, ConnectStoryMutation>
+    delete: ConnectReference<{ params: { id: string, storyId: string } }, ConnectStoryDeletion>
+    develop: ConnectReference<{ params: { id: string, storyId: string } }, ConnectJob>
+  }
+  pipeline: {
+    state: ConnectReference<{ params: ConnectPipelineParams }, ConnectPipelineState>
+    resume: ConnectReference<{
+      params: ConnectPipelineParams, body: ConnectPipelineResumeBody
+    }, ConnectJob>
+  }
+}
+
 /**
  * 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 = {
+export const connectRef: ConnectReferences = {
   capabilities: entrypointRef<{}, ConnectCapabilitiesView>(connect.capabilities),
   session: {
     open: entrypointRef<{ body: ConnectSessionOpen }, ConnectSessionView>(connect.session.open),
@@ -44,29 +92,8 @@ export const connectRef = {
     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),
@@ -77,9 +104,6 @@ export const connectRef = {
     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<{