@owlmeans/viable-common 0.0.4

package/build/connect/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../src/connect/consts.ts"],"names":[],"mappings":"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"}

package/build/connect/consts.js

@@ -0,0 +1,425 @@
+/**
+ * The connector contract — how an external coding agent drives the platform.
+ *
+ * A "connector session" is one external agent (Claude Code, Codex, Copilot, OpenCode, a CLI, a
+ * test) attached to one project. Two axes decide what the platform asks of it:
+ *
+ * - **target** — where the generated project's tree lives. `Cloud` is a publisher slot and the
+ *   platform reaches it as it always has; `Local` is a directory on the user's own machine, and
+ *   every file, shell and git command is executed THERE, by the connector, over this contract.
+ * - **llm** — who performs the model calls. `Cloud` is the platform's own configured presets,
+ *   billed in credits; `Local` hands each call to the parent agent as a MODEL TASK, which it runs
+ *   in a clean subagent and submits back.
+ *
+ * Everything here is serializable and runtime-free: the SDK, the manager API and the agent all
+ * read the same declarations, and none of them may reinvent a name the others parse.
+ */
+/** Where the target project's tree lives for this session. */
+export var ConnectTarget;
+(function (ConnectTarget) {
+    /** A publisher slot: the platform executes commands inside the pod, as it always has. */
+    ConnectTarget["Cloud"] = "cloud";
+    /** A directory on the user's machine: the connector executes the commands. */
+    ConnectTarget["Local"] = "local";
+})(ConnectTarget || (ConnectTarget = {}));
+/** Who performs the model calls of a run. */
+export var ConnectLlm;
+(function (ConnectLlm) {
+    /** The platform's configured presets — billed against the organization's credits. */
+    ConnectLlm["Cloud"] = "cloud";
+    /**
+     * The parent agent. Each call becomes a `ModelTask` the connector delivers, the parent runs in
+     * a clean subagent at low reasoning, and submits back as a `ModelTaskResult`.
+     *
+     * A paid capability, and an experimental one — see `CONNECT_CAP_LOCAL_LLM_KEY`.
+     */
+    ConnectLlm["Local"] = "local";
+})(ConnectLlm || (ConnectLlm = {}));
+/**
+ * The parent agents the connector knows how to instruct.
+ *
+ * It decides ONE thing: the wording of "how to run this task" in a model-task envelope, and the
+ * files `install_harness` writes. Anything the platform does differently per harness beyond those
+ * two is a bug — the protocol is the same for all of them.
+ */
+export var ConnectHarness;
+(function (ConnectHarness) {
+    ConnectHarness["ClaudeCode"] = "claude-code";
+    ConnectHarness["Codex"] = "codex";
+    ConnectHarness["Copilot"] = "copilot";
+    ConnectHarness["OpenCode"] = "opencode";
+    ConnectHarness["Other"] = "other";
+})(ConnectHarness || (ConnectHarness = {}));
+/** What a session is doing. */
+export var ConnectSessionStatus;
+(function (ConnectSessionStatus) {
+    ConnectSessionStatus["Active"] = "active";
+    /** The connector said goodbye. */
+    ConnectSessionStatus["Closed"] = "closed";
+    /** No presence for {@link CONNECT_SESSION_EXPIRE_MS}; nothing said goodbye. */
+    ConnectSessionStatus["Expired"] = "expired";
+    /** A newer session for the same project took over. */
+    ConnectSessionStatus["Superseded"] = "superseded";
+})(ConnectSessionStatus || (ConnectSessionStatus = {}));
+/** What a connector is able to execute on this session. */
+export var ConnectExecutor;
+(function (ConnectExecutor) {
+    ConnectExecutor["Files"] = "files";
+    ConnectExecutor["Shell"] = "shell";
+    ConnectExecutor["Git"] = "git";
+    /**
+     * The parent agent PERFORMS the model calls of a run: each one arrives as a `ModelTask`, is run
+     * in a clean subagent and submitted back. Present exactly when `llm` is `Local`.
+     */
+    ConnectExecutor["Model"] = "model";
+    /**
+     * A PERSON can be asked a question and their answer brought back.
+     *
+     * Advertised always, and by every connector: a parent agent has a human in front of it by
+     * definition, which is the whole reason the platform can ask one anything at all. It is not a
+     * narrower `Model` — a model task is inference the platform pays for either way, an inquiry is
+     * a decision only a person can make, and a run that cannot ask assumes instead.
+     */
+    ConnectExecutor["Human"] = "human";
+})(ConnectExecutor || (ConnectExecutor = {}));
+/** What one operation asks a connector to do. */
+export var ConnectOpKind;
+(function (ConnectOpKind) {
+    /** Run a slot command against the local tree — the same vocabulary a publisher answers. */
+    ConnectOpKind["SlotCommand"] = "slot-command";
+    /** Run one model call and submit its answer. */
+    ConnectOpKind["ModelTask"] = "model-task";
+    /** Write the target's configuration (its `.env` files) and report what services are reachable. */
+    ConnectOpKind["Configure"] = "configure";
+    /**
+     * Put one question to the person the connector is working for, and bring back their answer.
+     *
+     * An operation like any other — queued to the project, redelivered to whichever session is
+     * attached, answered against its own op id — because the alternative was a second channel with
+     * its own delivery, expiry and reattachment rules for the one payload that already had them.
+     */
+    ConnectOpKind["Inquiry"] = "inquiry";
+})(ConnectOpKind || (ConnectOpKind = {}));
+/** How a connector is receiving operations. */
+export var ConnectTransport;
+(function (ConnectTransport) {
+    ConnectTransport["Socket"] = "socket";
+    ConnectTransport["Pull"] = "pull";
+})(ConnectTransport || (ConnectTransport = {}));
+/** Why an operation failed, in the terms the platform reacts to. */
+export var ConnectOpErrorKind;
+(function (ConnectOpErrorKind) {
+    /** The answer did not match the shape asked for; ask again. */
+    ConnectOpErrorKind["Malformed"] = "malformed";
+    /** The connector executed and refused — a path outside the project, a protected file. */
+    ConnectOpErrorKind["Refused"] = "refused";
+    /** The connector cannot serve this at all; the run should stop. */
+    ConnectOpErrorKind["Unavailable"] = "unavailable";
+    /** The connector ran out of time. */
+    ConnectOpErrorKind["Timeout"] = "timeout";
+})(ConnectOpErrorKind || (ConnectOpErrorKind = {}));
+/** What shape a model task's answer came back in. */
+export var ModelTaskResultKind;
+(function (ModelTaskResultKind) {
+    ModelTaskResultKind["Text"] = "text";
+    ModelTaskResultKind["Json"] = "json";
+    ModelTaskResultKind["ToolCalls"] = "tool-calls";
+    ModelTaskResultKind["Error"] = "error";
+})(ModelTaskResultKind || (ModelTaskResultKind = {}));
+/**
+ * The power classes a parent agent offers, and the platform asks for.
+ *
+ * Three, because a parent has at most a few models and the platform has seventeen roles. The
+ * mapping is data ({@link MODEL_TIER_ROLES}) rather than a per-role negotiation: a parent says
+ * which of its models is strong, standard and cheap, and the platform stamps each role's tier onto
+ * the task it hands out. A parent offering fewer tiers gets its best available one — never a
+ * silent downgrade to nothing.
+ */
+export var ModelTier;
+(function (ModelTier) {
+    ModelTier["Strong"] = "strong";
+    ModelTier["Standard"] = "standard";
+    ModelTier["Cheap"] = "cheap";
+})(ModelTier || (ModelTier = {}));
+/**
+ * Role → tier.
+ *
+ * Keyed by the role names the platform's model presets use (`ChatModelPurpose` in
+ * `@owlmeans/viable`), listed here because the parent-facing contract must not depend on the
+ * library that defines them. A role absent from this table gets {@link ModelTier.Standard}.
+ */
+export const MODEL_TIER_ROLES = {
+    'senior-ba': ModelTier.Strong,
+    'senior-developer': ModelTier.Strong,
+    'senior-ui-developer': ModelTier.Strong,
+    'senior-designer': ModelTier.Strong,
+    'dev-orchestrator': ModelTier.Strong,
+    'backend-domain-architect': ModelTier.Strong,
+    'data-architect': ModelTier.Strong,
+    'api-architect': ModelTier.Strong,
+    'view-architect': ModelTier.Strong,
+    'state-architect': ModelTier.Strong,
+    'navigation-architect': ModelTier.Strong,
+    'middle-ba': ModelTier.Standard,
+    'middle-developer': ModelTier.Standard,
+    'middle-designer': ModelTier.Standard,
+    'product-manager': ModelTier.Standard,
+    'utility': ModelTier.Cheap,
+    'picker': ModelTier.Cheap,
+};
+export const tierOfRole = (role) => MODEL_TIER_ROLES[role] ?? ModelTier.Standard;
+/**
+ * Pick the best tier a parent actually offers, never below what was asked for by more than the
+ * offer allows.
+ *
+ * A parent that offers only one model answers every task with it; a parent that offers two gets
+ * the nearer of the two. Silence is not an option — a task the connector cannot place is a run
+ * that stops.
+ */
+export const clampTier = (wanted, offered) => {
+    if (offered.length < 1 || offered.includes(wanted))
+        return wanted;
+    const ladder = [ModelTier.Strong, ModelTier.Standard, ModelTier.Cheap];
+    const from = ladder.indexOf(wanted);
+    // Prefer a stronger model over a weaker one: the task was sized for `wanted`.
+    for (let i = from; i >= 0; --i)
+        if (offered.includes(ladder[i]))
+            return ladder[i];
+    for (let i = from + 1; i < ladder.length; ++i)
+        if (offered.includes(ladder[i]))
+            return ladder[i];
+    return wanted;
+};
+/** What the model task asks the parent's subagent to produce. */
+export var ModelTaskMode;
+(function (ModelTaskMode) {
+    /** Prose or code. */
+    ModelTaskMode["Text"] = "text";
+    /** Exactly one JSON object matching `outputSchema`. */
+    ModelTaskMode["Json"] = "json";
+    /** A JSON array of tool calls chosen from `tools`. */
+    ModelTaskMode["Tools"] = "tools";
+})(ModelTaskMode || (ModelTaskMode = {}));
+/** Who a message in a model task's conversation came from. */
+export var ModelTaskRole;
+(function (ModelTaskRole) {
+    ModelTaskRole["System"] = "system";
+    ModelTaskRole["User"] = "user";
+    ModelTaskRole["Assistant"] = "assistant";
+    ModelTaskRole["Tool"] = "tool";
+})(ModelTaskRole || (ModelTaskRole = {}));
+/** The KIND of thing a job is, so a parent can be told what it is waiting for. */
+export var ConnectJobKind;
+(function (ConnectJobKind) {
+    ConnectJobKind["ProjectCreate"] = "project-create";
+    ConnectJobKind["ProjectInit"] = "project-init";
+    ConnectJobKind["ProjectReinit"] = "project-reinit";
+    ConnectJobKind["StoryDevelop"] = "story-develop";
+    ConnectJobKind["FreeFlight"] = "free-flight";
+    ConnectJobKind["PipelineResume"] = "pipeline-resume";
+    /**
+     * The four stages of a conversion, plus the purge.
+     *
+     * One kind per stage rather than one for the whole conversion: each stage is its own platform
+     * pipeline run, ends at a decision the user makes, and is looked up by the pipeline alias its
+     * kind names. A single `convert` kind would match whichever run row happened to be newest.
+     */
+    ConnectJobKind["ConvertIntake"] = "convert-intake";
+    ConnectJobKind["ConvertAnalysis"] = "convert-analysis";
+    ConnectJobKind["ConvertExtraction"] = "convert-extraction";
+    ConnectJobKind["ConvertImplementation"] = "convert-implementation";
+    ConnectJobKind["ConvertPurge"] = "convert-purge";
+})(ConnectJobKind || (ConnectJobKind = {}));
+export var ConnectJobStatus;
+(function (ConnectJobStatus) {
+    ConnectJobStatus["Queued"] = "queued";
+    ConnectJobStatus["Running"] = "running";
+    /** Running, but waiting on the connector — see `ConnectJob.blockedOn`. */
+    ConnectJobStatus["Blocked"] = "blocked";
+    ConnectJobStatus["Done"] = "done";
+    ConnectJobStatus["Failed"] = "failed";
+})(ConnectJobStatus || (ConnectJobStatus = {}));
+/** What a blocked job is waiting for. */
+export var ConnectJobBlock;
+(function (ConnectJobBlock) {
+    /** Model tasks are queued and nobody is answering them. */
+    ConnectJobBlock["ModelTask"] = "model-task";
+    /** Slot commands are queued and no connector is attached. */
+    ConnectJobBlock["LocalOp"] = "local-op";
+    /** The local target has no database configured and the run needs one. */
+    ConnectJobBlock["Env"] = "env";
+    /** A question is waiting for a person and nobody has answered it. */
+    ConnectJobBlock["Question"] = "question";
+})(ConnectJobBlock || (ConnectJobBlock = {}));
+/**
+ * The shapes a question can take on the wire.
+ *
+ * Mirrors `InquiryKind` in `@owlmeans/llm-common` value for value, and is deliberately a SEPARATE
+ * name rather than an import: the connect module is the wire contract and owns its own vocabulary
+ * — the same reason `ModelTask` mirrors `DelegatedTask` — which also keeps `manager-api`, which
+ * does not depend on the model runtime, free of `@owlmeans/llm-common`. Values are byte-identical,
+ * so the platform's mapper is a widening rather than a translation table, and a test pins that.
+ */
+export var ConnectInquiryKind;
+(function (ConnectInquiryKind) {
+    /** Pick one of the offered options, or several when `multiple` is set. */
+    ConnectInquiryKind["Choice"] = "choice";
+    /** Free text. */
+    ConnectInquiryKind["Text"] = "text";
+    /** Yes or no. */
+    ConnectInquiryKind["Confirm"] = "confirm";
+})(ConnectInquiryKind || (ConnectInquiryKind = {}));
+/**
+ * How long the platform waits for a person to answer one question.
+ *
+ * The same forty-five minutes a model task gets, and for the same reason: the bound exists so a
+ * parent that has gone away eventually fails the step rather than holding a project lock forever,
+ * not to pace somebody who is thinking.
+ */
+export const CONNECT_INQUIRY_TIMEOUT_MS = 2_700_000;
+/** Options one choice question may offer. Beyond this it is a text question with a hint. */
+export const CONNECT_INQUIRY_MAX_OPTIONS = 12;
+/**
+ * The ceiling on an answer's text.
+ *
+ * ONE ceiling for the whole stack: the twin is `DEFAULT_INQUIRY_ANSWER_CHARS` in
+ * `@owlmeans/llm-common`, and the two must stay equal. Two ceilings means the layer with the
+ * larger one truncates silently at the smaller, and the caller records an assumption about an
+ * answer the person actually gave.
+ */
+export const CONNECT_INQUIRY_MAX_TEXT = 2_000;
+/**
+ * How long a session survives without a sign of life.
+ *
+ * A connector refreshes its presence on every socket ping, every long-poll and every submit. Ten
+ * minutes is generous on purpose: a parent agent running one model task in a subagent can be
+ * silent for several, and expiring a session under it would fail a run that was progressing.
+ */
+export const CONNECT_SESSION_EXPIRE_MS = 600_000;
+/** Presence key lifetime. Refreshed far more often than it expires. */
+export const CONNECT_PRESENCE_TTL_MS = 90_000;
+/**
+ * The longest a `pull` may hold its response open.
+ *
+ * Under the ~100 s an edge proxy allows an idle response, and under every MCP host's per-tool
+ * ceiling — Codex's default is 60 s. A poll that answers empty is not a failure; it is how a
+ * connector with nothing to do stays cheap.
+ */
+export const CONNECT_PULL_MAX_WAIT_MS = 45_000;
+/** Ops in flight for one project before a dispatcher waits for room. */
+export const CONNECT_MAX_PENDING = 32;
+/**
+ * How long the platform waits for a parent agent to answer one model task.
+ *
+ * Forty-five minutes: a subagent on a large refactor, a rate-limited provider, a human who walked
+ * away mid-turn. The bound exists so a dead parent eventually fails the step rather than holding a
+ * project lock forever — not to pace a working one.
+ */
+export const CONNECT_MODEL_TASK_TIMEOUT_MS = 2_700_000;
+/** How long the platform waits for a connector to write the target's configuration. */
+export const CONNECT_CONFIGURE_TIMEOUT_MS = 60_000;
+/**
+ * The capability key that gates the local-LLM mode.
+ *
+ * The scoped parameter a route passes to `entitled(...)` is composed by the platform, which owns
+ * the payment vocabulary — this is only the key a capability set stores.
+ */
+export const CONNECT_CAP_LOCAL_LLM_KEY = 'connect--local-llm';
+/** The access-token prefix the platform issues. Every connector token starts with it. */
+export const CONNECT_TOKEN_PREFIX = 'vib_';
+/**
+ * The marker a local project keeps so a connector attaching later knows which platform project it
+ * is. No secrets: an id, a slug and the API it belongs to.
+ */
+export const CONNECT_MARKER_FILE = '.viable/connect.json';
+/** Where a local run records its child processes. Never committed. */
+export const CONNECT_RUN_FILE = '.viable/run.json';
+/** Where a local target keeps the keypair its backend signs internal calls with. Never committed. */
+export const CONNECT_LOCAL_SECRETS_FILE = '.viable/local.json';
+/** The directory all three live in; a re-initialization must keep it. */
+export const CONNECT_MARKER_DIR = '.viable';
+/**
+ * The block a connector owns inside a target's `.env`.
+ *
+ * Everything between the markers is rewritten on every configure push; everything outside is the
+ * user's and is never touched. A local target's database URL is the user's line — the platform
+ * provisions no database on a developer's machine.
+ */
+export const CONNECT_ENV_BEGIN = '# --- viable:managed ---';
+export const CONNECT_ENV_END = '# --- /viable:managed ---';
+/** Socket events a connector session carries. */
+export const CONNECT_EVENT_OP = 'connect:op';
+export const CONNECT_EVENT_SESSION = 'connect:session';
+/** Redis resource aliases the platform registers for the relay. */
+export const CONNECT_OP_PUBSUB = 'connect-op-pubsub';
+export const CONNECT_RESULT_PUBSUB = 'connect-result-pubsub';
+export const CONNECT_OP_STORE = 'connect-op-store';
+export const CONNECT_SESSION_PUBSUB = 'connect-session-pubsub';
+/** The backend resource alias for session records. */
+export const RES_CONNECT_SESSION = 'connect-session';
+/**
+ * The connector's route ids.
+ *
+ * Owned here rather than by the platform because they ARE the contract: the SDK, the MCP host and
+ * the manager API all address the same aliases, and a client that had to be handed its own copy of
+ * the tree would be a second place for a name to drift. The platform spreads the declarations
+ * these produce into its own entrypoint list and elevates handlers onto them.
+ */
+export const connect = Object.freeze({
+    base: 'viable:manager-api:connect:base',
+    capabilities: 'viable:manager-api:connect:capabilities',
+    session: Object.freeze({
+        open: 'viable:manager-api:connect:session:open',
+        openDelegated: 'viable:manager-api:connect:session:open-delegated',
+        get: 'viable:manager-api:connect:session:get',
+        heartbeat: 'viable:manager-api:connect:session:heartbeat',
+        close: 'viable:manager-api:connect:session:close',
+        socket: 'viable:manager-api:connect:session:socket',
+    }),
+    op: Object.freeze({
+        pull: 'viable:manager-api:connect:op:pull',
+        submit: 'viable:manager-api:connect:op:submit',
+    }),
+    project: Object.freeze({
+        create: 'viable:manager-api:connect:project:create',
+        confirm: 'viable:manager-api:connect:project:confirm',
+        list: 'viable:manager-api:connect:project:list',
+        status: 'viable:manager-api:connect:project:status',
+        attach: 'viable:manager-api:connect:project:attach',
+        reinit: 'viable:manager-api:connect:project:reinit',
+        modify: 'viable:manager-api:connect:project:modify',
+        settings: 'viable:manager-api:connect:project:settings',
+        llm: 'viable:manager-api:connect:project:llm',
+        /** The per-project converter inference mode. Separate from `llm`: it is not a paid capability. */
+        converterLlm: 'viable:manager-api:connect:project:converter-llm',
+        job: 'viable:manager-api:connect:project:job',
+    }),
+    convert: Object.freeze({
+        create: 'viable:manager-api:connect:convert:create',
+        check: 'viable:manager-api:connect:convert:check',
+        start: 'viable:manager-api:connect:convert:start',
+        proceed: 'viable:manager-api:connect:convert:proceed',
+        cancel: 'viable:manager-api:connect:convert:cancel',
+        status: 'viable:manager-api:connect:convert:status',
+        purge: 'viable:manager-api:connect:convert:purge',
+    }),
+    inquiry: Object.freeze({
+        answer: 'viable:manager-api:connect:inquiry:answer',
+    }),
+    story: Object.freeze({
+        list: 'viable:manager-api:connect:story:list',
+        get: 'viable:manager-api:connect:story:get',
+        create: 'viable:manager-api:connect:story:create',
+        update: 'viable:manager-api:connect:story:update',
+        delete: 'viable:manager-api:connect:story:delete',
+        develop: 'viable:manager-api:connect:story:develop',
+    }),
+    files: Object.freeze({
+        list: 'viable:manager-api:connect:files:list',
+    }),
+    pipeline: Object.freeze({
+        state: 'viable:manager-api:connect:pipeline:state',
+        resume: 'viable:manager-api:connect:pipeline:resume',
+    }),
+});
+//# sourceMappingURL=consts.js.map

package/build/connect/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../../src/connect/consts.ts"],"names":[],"mappings":"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"}

package/build/connect/entrypoints.d.ts

@@ -0,0 +1,41 @@
+import type { CommonEntrypoint } from '@owlmeans/entrypoint';
+/**
+ * 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 declare const connectEntrypoints: (opts: ConnectEntrypointOptions) => CommonEntrypoint[];
+//# sourceMappingURL=entrypoints.d.ts.map

package/build/connect/entrypoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoints.d.ts","sourceRoot":"","sources":["../../src/connect/entrypoints.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAA2B,MAAM,sBAAsB,CAAA;AAcrF;;;;;;GAMG;AACH,MAAM,WAAW,wBAAwB;IACvC,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAC1C;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAC9C,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAA;IAClB,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,SAAU,wBAAwB,KAAG,gBAAgB,EAkPnF,CAAA"}

package/build/connect/entrypoints.js

@@ -0,0 +1,141 @@
+import { body, entrypoint, filter, gate, guard, params, query } 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';
+/**
+ * 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) => {
+    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 = 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)))),
+    ];
+};
+//# sourceMappingURL=entrypoints.js.map