import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";import { Schema } from "effect"; import { InternalError } from "@executor-js/sdk/shared"; // ---------------------------------------------------------------------------// Schemas// --------------------------------------------------------------------------- const ExecuteRequest = Schema.Struct({  code: Schema.String,  // When true the caller is the human approver: approval-gated tools run to  // completion instead of pausing. Set by the operator-facing Run/Test panel,  // where clicking Run is itself the approval. `block` policies still apply.  autoApprove: Schema.optional(Schema.Boolean),  /**   * Set when the caller is a rendered artifact rather than the console's own   * code surface — the artifact page has no MCP client, so the shell reaches   * the server here instead of through `execute-action`.   *   * It narrows the request in both directions: the code must be one   * proxy-shaped tool call, and the integration role it names is resolved   * through that artifact's stored connection bindings. Absent, this is   * ordinary codemode and nothing changes.   */  artifactId: Schema.optional(Schema.String),}); const CompletedResult = Schema.Struct({  status: Schema.Literal("completed"),  text: Schema.String,  structured: Schema.Unknown,  isError: Schema.Boolean,}); const PausedResult = Schema.Struct({  status: Schema.Literal("paused"),  text: Schema.String,  structured: Schema.Unknown,}); const ExecuteResponse = Schema.Union([CompletedResult, PausedResult]); const ResumeRequest = Schema.Struct({  action: Schema.Literals(["accept", "decline", "cancel"]),  content: Schema.optional(Schema.Unknown),  /** How long an accepted approval lasts, when the paused interaction's   *  terms offer a choice (`interaction.meta.persist` lists the scopes).   *  Omitted, the approval is for this call only. */  persist: Schema.optional(Schema.String),}); const ResumeResponse = Schema.Union([CompletedResult, PausedResult]); const PausedExecutionInfo = Schema.Struct({  text: Schema.String,  structured: Schema.Unknown,}); const ExecutionNotFoundError = Schema.TaggedStruct("ExecutionNotFoundError", {  executionId: Schema.String,}).annotate({ httpApiStatus: 404 }); /** * The approval window closed before the human answered. * * Separate from `ExecutionNotFoundError` because the two mean different things * to the person clicking Approve: an unknown id is a client bug, while an * expired approval is an ordinary outcome with a clear next step — nothing ran, * so triggering the action again is safe. The shell renders this as its * expired-approval state rather than an error. */const ApprovalExpiredError = Schema.TaggedStruct("ApprovalExpiredError", {  executionId: Schema.String,})  .annotate({ httpApiStatus: 410 })  .annotate({    description:      "The approval window closed before the action was approved. Nothing ran; trigger the action again.",  }); /** * An artifact-originated execution that could not be turned into a call: the * code was not the shell proxy's emission, the artifact is not this caller's, * or a role in it has no connection bound. * * `role` and `integration` accompany `binding_unresolved` so a client can offer * to rebind rather than only report the failure. */const ArtifactActionError = Schema.TaggedStruct("ArtifactActionError", {  error: Schema.Literals(["invalid_action_code", "artifact_unavailable", "binding_unresolved"]),  reason: Schema.String,  role: Schema.optional(Schema.String),  integration: Schema.optional(Schema.String),})  .annotate({ httpApiStatus: 400 })  .annotate({    description:      "A rendered artifact's tool call could not be resolved: bad shape, unknown artifact, or an unbound integration role.",  }); // ---------------------------------------------------------------------------// Params// --------------------------------------------------------------------------- const ExecutionParams = { executionId: Schema.String }; // ---------------------------------------------------------------------------// Group// --------------------------------------------------------------------------- export const ExecutionsApi = HttpApiGroup.make("executions")  .add(    HttpApiEndpoint.get("getPaused", "/executions/:executionId", {      params: ExecutionParams,      success: PausedExecutionInfo,      error: [InternalError, ExecutionNotFoundError],    }),  )  .add(    HttpApiEndpoint.post("execute", "/executions", {      payload: ExecuteRequest,      success: ExecuteResponse,      error: [InternalError, ArtifactActionError],    }),  )  .add(    HttpApiEndpoint.post("resume", "/executions/:executionId/resume", {      params: ExecutionParams,      payload: ResumeRequest,      success: ResumeResponse,      error: [InternalError, ExecutionNotFoundError, ApprovalExpiredError],    }),  );