@galaxyproject/orbit 0.0.0 → 0.9.0

package/extensions/orbit/galaxy-job-block.ts

@@ -0,0 +1,347 @@
+/**
+ * `loom-job` notebook blocks: the tool-run equivalent of `loom-invocation`.
+ *
+ * The background poller advances work by scanning the notebook for in-flight
+ * blocks, but it only ever knew about workflow invocations. A session driven
+ * with single Galaxy *tool* runs recorded nothing pollable, so every tick took
+ * the cheap early-return path, nothing advanced, no completion toast fired --
+ * and the analysis sat still until the user typed "status?" (#413).
+ *
+ * Deliberately a separate fence rather than a flag on InvocationYaml: an
+ * invocation id and a job id go to different Galaxy endpoints, and a job id
+ * parsed as an invocation would send the existing polling tools to
+ * /api/invocations/<job id> and fail. Separate types keep that mistake
+ * unrepresentable.
+ *
+ * Format matches loom-invocation: line-oriented and grep-friendly, so the
+ * blocks stay readable in a diff and survive hand edits.
+ *
+ * ```loom-job
+ * job_id: abc123
+ * galaxy_server_url: https://usegalaxy.org
+ * notebook_anchor: plan-1-step-3
+ * label: BWA alignment
+ * tool_id: bwa_mem
+ * submitted_at: 2026-08-12T15:30:00Z
+ * status: in_progress
+ * summary: ""
+ * ```
+ */
+
+import { notebookFenceOpen, replaceNotebookBlocks } from "../../shared/notebook-fences.js";
+import { appendBlock, isUnambiguousRange } from "./notebook-writer";
+import {
+  blockLine,
+  isFoldableDuplicate,
+  scanFencedBlocks,
+  mergeHarnessFields,
+  parseHarnessFields,
+  renderHarnessFieldLines,
+  stripHarnessFields,
+  type HarnessBlockFields,
+} from "./harness-block-fields";
+
+export interface JobYaml extends HarnessBlockFields {
+  jobId: string;
+  galaxyServerUrl: string;
+  notebookAnchor: string;
+  label: string;
+  toolId?: string;
+  submittedAt: string;
+  status: "in_progress" | "completed" | "failed" | "cancelled" | "skipped";
+  summary?: string;
+  /**
+   * Whether Galaxy confirmed this job id exists at record time. `false` means
+   * the record tool asked and got no answer, not that the job is fake; the
+   * poller sets it true on its first successful poll. Absent means the block
+   * predates the field. Mirrors the same field on `InvocationYaml`.
+   */
+  serverVerified?: boolean;
+  /** Galaxy's raw job state at the last poll, kept for display and debugging. */
+  galaxyState?: string;
+  lastPolledAt?: string;
+}
+
+const JOB_FENCE_OPEN = notebookFenceOpen("job");
+const JOB_FENCE_CLOSE = "```";
+
+/**
+ * How each Galaxy job state (JobState in lib/galaxy/schema/schema.py) lands in
+ * the block. A state listed here stops the polling; anything absent -- known
+ * running states and any state Galaxy adds later -- leaves the block
+ * in_progress, which is the safe default: we keep watching rather than
+ * declaring an outcome we can't name.
+ *
+ * Two distinctions this table exists to make, both of which cost us a bug:
+ *
+ * Ending is not the same as failing. `deleted` and `stopped` are the user
+ * cancelling their own job, and `skipped` is a workflow conditional choosing
+ * not to run a step. Reporting those as failures sends the agent off to
+ * investigate a malfunction that never happened -- Galaxy's own workflow UI
+ * counts skipped alongside successful jobs.
+ *
+ * Ending is also not the same as heading for the exit. `deleting` and `stop`
+ * (the wire value of STOPPING) are transitional: Galaxy's job handler advances
+ * them to `deleted` and `stopped`. Treating them as terminal freezes the block
+ * on a state the job has already left, and because the poller only revisits
+ * in_progress blocks, nothing ever corrects it.
+ *
+ * `paused` is likewise not terminal: it resumes when its inputs arrive, or when
+ * the user resumes it explicitly.
+ */
+const JOB_STATE_OUTCOME: Readonly<Record<string, Exclude<JobYaml["status"], "in_progress">>> = {
+  ok: "completed",
+  error: "failed",
+  failed: "failed",
+  deleted: "cancelled",
+  stopped: "cancelled",
+  skipped: "skipped",
+};
+
+/**
+ * Every status the block may carry. Parsing has to recognise all of them: a
+ * terminal status it doesn't know reads back as in_progress, so the poller
+ * picks the job up again, rewrites the same outcome, and re-announces it on
+ * every tick.
+ */
+const JOB_STATUSES: readonly JobYaml["status"][] = [
+  "in_progress",
+  "completed",
+  "failed",
+  "cancelled",
+  "skipped",
+];
+
+function isJobStatus(value: string | undefined): value is JobYaml["status"] {
+  return !!value && (JOB_STATUSES as readonly string[]).includes(value);
+}
+
+export function isTerminalJobState(state: string | undefined): boolean {
+  if (!state) return false;
+  return state.toLowerCase() in JOB_STATE_OUTCOME;
+}
+
+/** Map a Galaxy job state onto the block's coarse status. */
+export function jobStatusFromGalaxyState(state: string | undefined): JobYaml["status"] {
+  if (!state) return "in_progress";
+  return JOB_STATE_OUTCOME[state.toLowerCase()] ?? "in_progress";
+}
+
+function escapeYaml(value: string): string {
+  // Same conservative rule the invocation block uses: quote anything that
+  // could be read as YAML structure, leave plain scalars alone.
+  if (value === "") return '""';
+  if (/^[\w .\-/]+$/.test(value)) return value;
+  return JSON.stringify(value);
+}
+
+function unescapeYaml(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"')) {
+    try {
+      return JSON.parse(trimmed) as string;
+    } catch {
+      return trimmed;
+    }
+  }
+  return trimmed;
+}
+
+/** Render a job as a `loom-job` fenced block, trailing newline included. */
+export function renderJobYaml(job: JobYaml): string {
+  const lines: string[] = [
+    JOB_FENCE_OPEN,
+    blockLine("job_id", job.jobId, "jobId"),
+    blockLine("galaxy_server_url", job.galaxyServerUrl),
+    blockLine("notebook_anchor", job.notebookAnchor, "notebookAnchor"),
+    `label: ${escapeYaml(job.label)}`,
+  ];
+  if (job.toolId) lines.push(blockLine("tool_id", job.toolId, "toolId"));
+  lines.push(blockLine("submitted_at", job.submittedAt));
+  lines.push(`status: ${job.status}`);
+  lines.push(`summary: ${escapeYaml(job.summary ?? "")}`);
+  if (job.serverVerified !== undefined) lines.push(`server_verified: ${job.serverVerified}`);
+  if (job.galaxyState) lines.push(blockLine("galaxy_state", job.galaxyState));
+  if (job.lastPolledAt) lines.push(blockLine("last_polled_at", job.lastPolledAt));
+  lines.push(...renderHarnessFieldLines(job));
+  lines.push(JOB_FENCE_CLOSE);
+  return lines.join("\n") + "\n";
+}
+
+function parseBooleanField(raw: string | undefined): boolean | undefined {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  return undefined;
+}
+
+/**
+ * The block's `key: value` lines, untouched. The upsert reads carry-forward
+ * provenance through here as well as the parser, because provenance has to
+ * survive a block the parser rejects -- see `upsertJobBlock`.
+ */
+function rawJobFields(blockLines: string[]): Map<string, string> {
+  const map = new Map<string, string>();
+  for (const line of blockLines) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    map.set(line.slice(0, idx).trim(), line.slice(idx + 1).trim());
+  }
+  return map;
+}
+
+function parseJobBlock(blockLines: string[]): JobYaml | null {
+  const map = rawJobFields(blockLines);
+  const jobId = map.get("job_id");
+  if (!jobId) return null; // a block without an id is not pollable
+  const status = map.get("status");
+  return {
+    jobId,
+    galaxyServerUrl: map.get("galaxy_server_url") ?? "",
+    notebookAnchor: map.get("notebook_anchor") ?? "",
+    label: unescapeYaml(map.get("label") ?? ""),
+    toolId: map.get("tool_id") || undefined,
+    submittedAt: map.get("submitted_at") ?? "",
+    status: isJobStatus(status) ? status : "in_progress",
+    summary: unescapeYaml(map.get("summary") ?? "") || undefined,
+    // Absent or unreadable both mean "nobody has claimed this", which is the
+    // honest default for a flag about a server round trip.
+    serverVerified: parseBooleanField(map.get("server_verified")),
+    galaxyState: map.get("galaxy_state") || undefined,
+    lastPolledAt: map.get("last_polled_at") || undefined,
+    // `map` holds raw values (nothing here runs unescapeYaml), which is what
+    // the harness fields want: bare tokens and single-line JSON.
+    ...parseHarnessFields((key) => map.get(key)),
+  };
+}
+
+interface BlockRange {
+  jobId: string;
+  start: number;
+  end: number;
+}
+
+function findJobBlockRanges(content: string): BlockRange[] {
+  const lines = content.split("\n");
+  const ranges: BlockRange[] = [];
+  for (const range of scanFencedBlocks(lines, "job")) {
+    const parsed = parseJobBlock(lines.slice(range.start + 1, range.end));
+    if (parsed) ranges.push({ jobId: parsed.jobId, start: range.start, end: range.end });
+  }
+  return ranges;
+}
+
+/** Every parseable `loom-job` block in the notebook. Invalid blocks are skipped. */
+export function findJobBlocks(content: string): JobYaml[] {
+  const lines = content.split("\n");
+  const result: JobYaml[] = [];
+  for (const range of scanFencedBlocks(lines, "job")) {
+    const parsed = parseJobBlock(lines.slice(range.start + 1, range.end));
+    if (parsed) result.push(parsed);
+  }
+  return result;
+}
+
+/**
+ * Find the first `loom-job` block physically carrying this id, and what it
+ * parses to. The invocation side's twin -- see `locateInvocationBlock` for why
+ * one physical block has to answer both questions.
+ */
+export function locateJobBlock(
+  content: string,
+  jobId: string,
+): { present: boolean; record: JobYaml | null } {
+  const lines = content.split("\n");
+  const range = findJobBlockRanges(content).find((b) => b.jobId === jobId);
+  if (!range) return { present: false, record: null };
+  return { present: true, record: parseJobBlock(lines.slice(range.start + 1, range.end)) };
+}
+
+/**
+ * Upsert a `loom-job` block keyed by `job_id`: replace in place when the id is
+ * already present, otherwise append at the end.
+ *
+ * Harness-only fields on `job` are discarded; see `upsertInvocationBlock` in
+ * notebook-writer.ts for why. They are carried over from the block on disk,
+ * or supplied explicitly through `harness` by the auto-registration path.
+ */
+export function upsertJobBlock(
+  content: string,
+  job: JobYaml,
+  harness?: HarnessBlockFields,
+): string {
+  const ranges = findJobBlockRanges(content);
+  const lines = content.split("\n");
+
+  // Only a range no unclosed fence precedes can be replaced -- see
+  // isUnambiguousRange. More than one can match when an older writer used the
+  // other fence prefix; foldable duplicates collapse into the rewritten block.
+  const matching = ranges.filter(
+    (b) => b.jobId === job.jobId && isUnambiguousRange(lines, b.start),
+  );
+  const existing = matching[0];
+  // Read off the block this write replaces, not a second scan of the file --
+  // see the same comment in `upsertInvocationBlock`.
+  const onDiskRaw = existing ? rawJobFields(lines.slice(existing.start + 1, existing.end)) : null;
+  const onDisk = parseHarnessFields((key) => onDiskRaw?.get(key));
+  const merged: JobYaml = {
+    ...stripHarnessFields(job),
+    ...mergeHarnessFields(onDisk, harness ?? {}),
+  };
+  const newBlock = renderJobYaml(merged).trimEnd().split("\n");
+
+  if (existing) {
+    const replaced = matching.filter(
+      (b) =>
+        b === existing ||
+        isFoldableDuplicate(
+          onDiskRaw?.get("attempt_id"),
+          rawJobFields(lines.slice(b.start + 1, b.end)).get("attempt_id"),
+        ),
+    );
+    return replaceNotebookBlocks(content, replaced, newBlock);
+  }
+
+  return appendBlock(content, newBlock);
+}
+
+/**
+ * What one poll learned. Deliberately not a whole JobYaml: `label`,
+ * `notebook_anchor` and `submitted_at` belong to whoever recorded the job, and
+ * writing back a copy captured before the Galaxy round trip would clobber an
+ * edit made in the meantime -- the same hazard the invocation poller documents.
+ */
+export interface JobPollUpdate {
+  jobId: string;
+  /**
+   * The outcome this poll decided, or omitted for an update that isn't about
+   * the outcome at all -- a verification-only write, say. Omitting is not the
+   * same as passing the status the caller last saw: that copy predates whatever
+   * landed while we were talking to Galaxy, and writing it back would revert
+   * another writer's transition.
+   */
+  status?: JobYaml["status"];
+  galaxyState?: string;
+  lastPolledAt: string;
+  summary?: string;
+  /**
+   * True when this update came from a Galaxy round trip that answered, which is
+   * proof the id exists. Same rule as the invocation side: it clears a block
+   * recorded `server_verified: false` and leaves an unstamped one alone.
+   */
+  serverVerified?: boolean;
+}
+
+/** Apply a poll result to whichever block carries that job id. No-op if absent. */
+export function applyJobPollUpdate(content: string, update: JobPollUpdate): string {
+  const current = findJobBlocks(content).find((j) => j.jobId === update.jobId);
+  if (!current) return content;
+  return upsertJobBlock(content, {
+    ...current,
+    status: update.status ?? current.status,
+    galaxyState: update.galaxyState ?? current.galaxyState,
+    lastPolledAt: update.lastPolledAt,
+    summary: update.summary ?? current.summary,
+    serverVerified:
+      update.serverVerified && current.serverVerified === false ? true : current.serverVerified,
+  });
+}

package/extensions/orbit/galaxy-job-ops.ts

@@ -0,0 +1,288 @@
+/**
+ * The job reads Orbit's model needs that galaxy-ops 0.3.1 does not have, written as galaxy-ops
+ * operations so they run through the same wrapper as every other Galaxy tool: one envelope, the
+ * same failure kinds and deadline, Python-shaped failure wording from their `failure` contracts.
+ *
+ * `run_tool` answers with job ids, and the model polls them, but galaxy-ops' get_job_details only
+ * finds a job from the dataset it made. The bridge reads a job by its own id as well, and keeps
+ * the dataset route as galaxy-ops wrote it. list_jobs and get_job_logs have no galaxy-ops
+ * counterpart at all. They all go away when galaxy-ops ships the same operations.
+ */
+import {
+  getJobDetailsOp,
+  GalaxyConnectionError,
+  GalaxyValidationError,
+  httpError,
+  type AnyOperation,
+  type GalaxyContext,
+  type GetJobDetailsResult,
+  type JobDetail,
+  type Operation,
+} from "@galaxyproject/galaxy-ops";
+import { isGalaxyEncodedId } from "./galaxy-api";
+import type { GalaxyOpArgs } from "./galaxy-op-policy";
+import type { GalaxyBridge } from "./galaxy-ops-tools";
+
+/** A job id is a URL path segment; anything else could walk the URL to another endpoint. */
+function encodedJobId(jobId: string): string {
+  if (!isGalaxyEncodedId(jobId)) {
+    throw new GalaxyValidationError(
+      `job_id '${jobId}' is not a Galaxy job id. Job ids are the hexadecimal strings run_tool and list_jobs return; pass one back exactly.`,
+    );
+  }
+  return jobId;
+}
+
+async function fetchJob(
+  ctx: GalaxyContext,
+  jobId: string,
+  full: boolean,
+): Promise<Record<string, unknown>> {
+  const { data, error, response } = await ctx.client.GET("/api/jobs/{job_id}", {
+    params: { path: { job_id: jobId }, ...(full ? { query: { full: true } } : {}) },
+  });
+  if (error || !data) throw httpError(response, error);
+  return data as Record<string, unknown>;
+}
+
+// The added and relaxed fields come from the operation's own zod fields, so they render, parse
+// and laxen through galaxy-ops' zod like every other parameter. dataset_id stops being required
+// because a job id alone is now enough.
+const jobDetailsInput = {
+  ...getJobDetailsOp.input,
+  datasetId: getJobDetailsOp.input.datasetId.optional(),
+  jobId: getJobDetailsOp.input.datasetId
+    .describe("Galaxy job id, as run_tool returns it. Give job_id or dataset_id.")
+    .optional(),
+};
+
+/** The dataset route's shape on both routes, so the poll guard and parsers read one result. */
+type JobDetailsOut = Omit<GetJobDetailsResult, "dataset_id"> & { dataset_id: string | null };
+
+const byJob = (i: { jobId?: string }): i is { jobId: string } => i.jobId !== undefined;
+const baseFailure = getJobDetailsOp.failure;
+
+const getJobDetailsBridgeOp: Operation<typeof jobDetailsInput, JobDetailsOut> = {
+  ...getJobDetailsOp,
+  input: jobDetailsInput,
+  async run(i, ctx) {
+    if (byJob(i)) {
+      const jobId = encodedJobId(i.jobId);
+      const job = (await fetchJob(ctx, jobId, false)) as JobDetail;
+      return { job, dataset_id: null, job_id: jobId };
+    }
+    if (i.datasetId === undefined) {
+      throw new GalaxyValidationError("Give job_id (from run_tool) or dataset_id.");
+    }
+    return getJobDetailsOp.run({ datasetId: i.datasetId, historyId: i.historyId }, ctx);
+  },
+  project(out, i, facts) {
+    if (byJob(i)) return { message: `Retrieved job details for job '${out.job_id}'` };
+    return (
+      getJobDetailsOp.project?.(
+        out as GetJobDetailsResult,
+        { datasetId: out.dataset_id ?? "", historyId: i.historyId },
+        facts,
+      ) ?? {}
+    );
+  },
+  failure: baseFailure && {
+    shape: baseFailure.shape,
+    action: baseFailure.action,
+    context: (i) =>
+      byJob(i)
+        ? { job_id: i.jobId }
+        : (baseFailure.context?.({ datasetId: i.datasetId ?? "", historyId: i.historyId }) ?? {}),
+    // The base sentence names the dataset; on the job route there is none to name.
+    sentence: (text, status, i) =>
+      byJob(i)
+        ? undefined
+        : baseFailure.sentence?.(text, status, {
+            datasetId: i.datasetId ?? "",
+            historyId: i.historyId,
+          }),
+  },
+};
+
+export const getJobDetailsBridge: GalaxyBridge = {
+  op: getJobDetailsBridgeOp as unknown as AnyOperation,
+  note: "Pass job_id to read a job directly, or dataset_id to find the job that made a dataset.",
+};
+
+/** The model's snake_case keys under these operations' camelCase ones. */
+const renamed =
+  (names: Record<string, string>) =>
+  (args: GalaxyOpArgs): GalaxyOpArgs =>
+    Object.fromEntries(Object.entries(args).map(([k, v]) => [names[k] ?? k, v]));
+
+const JOB_ID_PARAMETER = {
+  type: "string",
+  description: "Galaxy job id, as run_tool or list_jobs returns it.",
+} as const;
+
+const LIST_JOBS_LIMIT = { default: 50, max: 500 } as const;
+
+function wholeNumber(name: string, value: unknown, fallback: number, max?: number): number {
+  if (value === undefined || value === null) return fallback;
+  const ok =
+    typeof value === "number" &&
+    Number.isInteger(value) &&
+    value >= (max === undefined ? 0 : 1) &&
+    (max === undefined || value <= max);
+  if (!ok) {
+    const range = max === undefined ? "0 or greater" : `from 1 to ${max}`;
+    throw new GalaxyValidationError(`${name} must be a whole number ${range} (got ${value}).`);
+  }
+  return value;
+}
+
+interface ListJobsInput {
+  historyId?: unknown;
+  limit?: unknown;
+  offset?: unknown;
+}
+
+const listJobsOp = {
+  name: "list_jobs",
+  domain: "jobs",
+  summary:
+    "List the jobs in a history, newest first: each row's id, tool_id, state and create_time. Use it to find the job behind a step or to see what is still running; get_job_details and get_job_logs take a row's id.",
+  input: {},
+  readOnly: true,
+  async run(i: ListJobsInput, ctx: GalaxyContext): Promise<unknown[]> {
+    if (typeof i.historyId !== "string" || i.historyId === "") {
+      throw new GalaxyValidationError("list_jobs needs history_id.");
+    }
+    const limit = wholeNumber("limit", i.limit, LIST_JOBS_LIMIT.default, LIST_JOBS_LIMIT.max);
+    const offset = wholeNumber("offset", i.offset, 0);
+    const { data, error, response } = await ctx.client.GET("/api/jobs", {
+      params: {
+        query: {
+          history_id: i.historyId,
+          view: "collection",
+          order_by: "create_time",
+          // Galaxy sends no total, so one row past the page is how project knows another exists.
+          limit: limit + 1,
+          offset,
+        },
+      },
+    });
+    if (error || !data) throw httpError(response, error);
+    // A non-list here is not a job index at all; reading it as zero jobs would hide that.
+    if (!Array.isArray(data)) {
+      throw new GalaxyConnectionError("Galaxy's job index did not return a list");
+    }
+    return data as unknown[];
+  },
+  project: (rows: unknown[], i: ListJobsInput) => {
+    // run already refused anything these would throw on.
+    const limit = wholeNumber("limit", i.limit, LIST_JOBS_LIMIT.default, LIST_JOBS_LIMIT.max);
+    const offset = wholeNumber("offset", i.offset, 0);
+    const page = rows.slice(0, limit);
+    const hasNext = rows.length > limit;
+    const next = offset + page.length;
+    return {
+      data: page,
+      message: `Retrieved ${page.length} jobs for history '${String(i.historyId)}'`,
+      count: page.length,
+      pagination: {
+        // A lower bound: Galaxy's job index does not count the rest.
+        total_items: offset + rows.length,
+        returned_items: page.length,
+        limit,
+        offset,
+        has_next: hasNext,
+        has_previous: offset > 0,
+        next_offset: hasNext ? next : null,
+        previous_offset: offset > 0 ? Math.max(0, offset - limit) : null,
+        helper_text:
+          `Showing ${page.length} jobs from offset ${offset}. ` +
+          (hasNext ? `Use offset=${next} for the next page.` : "This is the last page."),
+      },
+    };
+  },
+  failure: {
+    shape: "raise-for-status",
+    action: "List jobs",
+    context: (i: ListJobsInput) => ({ history_id: i.historyId }),
+  },
+};
+
+export const listJobsBridge: GalaxyBridge = {
+  op: listJobsOp as unknown as AnyOperation,
+  parameters: {
+    type: "object",
+    properties: {
+      history_id: { type: "string", description: "Encoded id of the history whose jobs to list." },
+      limit: {
+        type: "integer",
+        minimum: 1,
+        maximum: LIST_JOBS_LIMIT.max,
+        default: LIST_JOBS_LIMIT.default,
+        description: `Most jobs to return (default ${LIST_JOBS_LIMIT.default}, at most ${LIST_JOBS_LIMIT.max}).`,
+      },
+      offset: {
+        type: "integer",
+        minimum: 0,
+        default: 0,
+        description: "Jobs to skip from the newest, for the next page (default 0).",
+      },
+    },
+    required: ["history_id"],
+    additionalProperties: false,
+  },
+  inputOf: renamed({ history_id: "historyId" }),
+};
+
+/** Every log a job can carry, as `GET /api/jobs/{id}?full=true` names them. */
+const LOG_FIELDS = [
+  "state",
+  "exit_code",
+  "stdout",
+  "stderr",
+  "job_stdout",
+  "job_stderr",
+  "tool_stdout",
+  "tool_stderr",
+] as const;
+
+interface JobLogsInput {
+  jobId?: unknown;
+}
+
+const getJobLogsOp = {
+  name: "get_job_logs",
+  domain: "jobs",
+  summary:
+    "Get a job's state, exit code and logs: stdout and stderr as the tool and as Galaxy's job runner wrote them. Read these to see why a job failed.",
+  input: {},
+  readOnly: true,
+  async run(i: JobLogsInput, ctx: GalaxyContext): Promise<Record<string, unknown>> {
+    if (typeof i.jobId !== "string") throw new GalaxyValidationError("get_job_logs needs job_id.");
+    const jobId = encodedJobId(i.jobId);
+    const job = await fetchJob(ctx, jobId, true);
+    // Only what the server sent: an absent log is not an empty one.
+    const out: Record<string, unknown> = { job_id: jobId };
+    for (const key of LOG_FIELDS) if (key in job) out[key] = job[key];
+    return out;
+  },
+  project: (_out: unknown, i: JobLogsInput) => ({
+    message: `Retrieved logs for job '${String(i.jobId)}'`,
+  }),
+  failure: {
+    shape: "raise-for-status",
+    action: "Get job logs",
+    context: (i: JobLogsInput) => ({ job_id: i.jobId }),
+  },
+};
+
+export const getJobLogsBridge: GalaxyBridge = {
+  op: getJobLogsOp as unknown as AnyOperation,
+  parameters: {
+    type: "object",
+    properties: { job_id: JOB_ID_PARAMETER },
+    required: ["job_id"],
+    additionalProperties: false,
+  },
+  inputOf: renamed({ job_id: "jobId" }),
+};