@lunnoa/client 2.4.0 → 3.0.0

package/dist/react.js

@@ -76,16 +76,21 @@ var LunnoaApiError = class extends Error {
   method;
   /** Path of the failed request (without the base URL). */
   path;
+  /** Present on definition-sync 409s when the server sends the current revision. */
+  currentRevision;
   constructor(args) {
     const detail = extractMessage(args.body);
+    const currentRevision = extractCurrentRevision(args.body);
+    const shown = [detail, currentRevision ? `currentRevision: ${currentRevision}` : void 0].filter(Boolean).join(" ");
     super(
-      `Lunnoa API request failed: ${args.method} ${args.path} \u2192 ${args.status}${detail ? ` (${detail})` : ""}`
+      `Lunnoa API request failed: ${args.method} ${args.path} \u2192 ${args.status}${shown ? ` (${shown})` : ""}`
     );
     this.name = "LunnoaApiError";
     this.status = args.status;
     this.body = args.body;
     this.method = args.method;
     this.path = args.path;
+    this.currentRevision = currentRevision;
   }
   /** True for 401 responses (missing, revoked, or expired credential). */
   get isUnauthorized() {
@@ -104,6 +109,11 @@ var LunnoaApiError = class extends Error {
     return this.status === 429;
   }
 };
+function extractCurrentRevision(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const revision = body.currentRevision;
+  return typeof revision === "string" ? revision : void 0;
+}
 function extractMessage(body) {
   if (body && typeof body === "object") {
     const record = body;
@@ -580,10 +590,55 @@ var ActionsResource = class {
   }
 };
 
+// src/define/files.ts
+function hasFileAgentSignals(record) {
+  if (record.instructions && typeof record.instructions === "object") return true;
+  if (record.settings && typeof record.settings === "object") return true;
+  if ("workflows" in record || "agents" in record || "knowledge" in record || "variables" in record || "objects" in record || "objectTypes" in record || "mcpServers" in record || "a2aAgents" in record) {
+    return true;
+  }
+  return Array.isArray(record.tools) && record.tools.some(
+    (tool) => tool && typeof tool === "object" && !("kind" in tool) && !("use" in tool)
+  );
+}
+function isAgentFileShape(config) {
+  if (!config || typeof config !== "object") return false;
+  return hasFileAgentSignals(config);
+}
+
 // src/define/index.ts
 var DEFINE_KINDS = {
+  connection: "connection",
   action: "action",
+  trigger: "trigger",
   workflow: "workflow"};
+var PATH_CONDITIONS = [
+  "contains",
+  "does_not_contain",
+  "equals",
+  "does_not_equal",
+  "exists",
+  "does_not_exist",
+  "starts_with",
+  "ends_with",
+  "is_empty",
+  "is_not_empty",
+  "comes_before",
+  "comes_after",
+  "is_in_the_past",
+  "is_in_the_future",
+  "is_true",
+  "is_false",
+  "is_truthy",
+  "is_falsey",
+  "is_greater_than",
+  "is_less_than",
+  "is_greater_than_or_equal_to",
+  "is_less_than_or_equal_to",
+  "matches_regex",
+  "does_not_match_regex"
+];
+new Set(PATH_CONDITIONS);
 function resolveActionAppId(action) {
   if (action.appId?.trim()) {
     return action.appId.trim();
@@ -684,10 +739,24 @@ function unwrapTool(tool) {
   }
   return tool;
 }
+function syncFields(options) {
+  return {
+    ...options?.baseRevision ? { baseRevision: options.baseRevision } : {},
+    ...options?.force ? { force: true } : {}
+  };
+}
+function idsOf(links) {
+  if (!links) return void 0;
+  return links.map((link) => link.id);
+}
 function agentDefinitionToUpsert(def, options) {
+  if (isAgentFileShape(def)) {
+    return fileAgentToUpsert(def, options);
+  }
   const tools = [];
   const workflowIds = [...options?.workflowIds ?? []];
-  for (const tool of def.tools ?? []) {
+  const authored = def;
+  for (const tool of authored.tools ?? []) {
     const unwrapped = unwrapTool(tool);
     if (unwrapped.kind === DEFINE_KINDS.workflow) {
       continue;
@@ -703,17 +772,64 @@ function agentDefinitionToUpsert(def, options) {
       });
     }
   }
+  return {
+    slug: authored.slug,
+    name: authored.name,
+    description: authored.description,
+    instructions: authored.instructions,
+    model: authored.model,
+    aiConnectionId: authored.aiConnection?.id,
+    connectionIds: authored.connections?.map((c) => c.id).filter((id) => Boolean(id)),
+    workflowIds: workflowIds.length ? workflowIds : void 0,
+    tools,
+    codeSource: options?.codeSource ?? "generated",
+    ...syncFields(options)
+  };
+}
+function fileAgentToUpsert(def, options) {
+  if (typeof def.instructions !== "string") {
+    throw new Error(
+      "Agent instructions are still a file reference. The CLI resolves these before push."
+    );
+  }
+  const tools = [];
+  for (const tool of def.tools ?? []) {
+    const action = {
+      id: tool.id,
+      appId: tool.appId,
+      connection: tool.connection?.id ? { id: tool.connection.id } : void 0
+    };
+    tools.push({
+      key: tool.key,
+      appId: resolveActionAppId(action),
+      actionId: resolveActionId(action),
+      connectionId: tool.connection?.id,
+      name: tool.name,
+      description: tool.description,
+      input: tool.input
+    });
+  }
   return {
     slug: def.slug,
     name: def.name,
-    description: def.description,
+    // A file is the whole definition. Omitted description and model are empty.
+    description: def.description ?? null,
     instructions: def.instructions,
-    model: def.model,
+    model: def.model ?? null,
     aiConnectionId: def.aiConnection?.id,
-    connectionIds: def.connections?.map((c) => c.id).filter((id) => Boolean(id)),
-    workflowIds: workflowIds.length ? workflowIds : void 0,
-    tools,
-    managedByCode: true
+    ...def.settings ? { settings: def.settings } : {},
+    ...def.tools ? { tools } : {},
+    ...def.workflows ? { workflows: def.workflows } : {},
+    ...def.agents ? { agents: def.agents } : {},
+    ...def.connections ? { connectionIds: idsOf(def.connections) } : {},
+    ...def.knowledge ? { knowledgeIds: idsOf(def.knowledge) } : {},
+    ...def.variables ? { variableIds: idsOf(def.variables) } : {},
+    ...def.objects ? { objectIds: idsOf(def.objects) } : {},
+    ...def.objectTypes ? { objectTypeIds: idsOf(def.objectTypes) } : {},
+    ...def.mcpServers ? { mcpServers: def.mcpServers } : {},
+    ...def.a2aAgents ? { a2aAgentIds: idsOf(def.a2aAgents) } : {},
+    codeSource: "synced",
+    ...syncFields(options)
   };
 }
 var AgentsResource = class {
@@ -733,15 +849,22 @@ var AgentsResource = class {
       query: serializeListQuery(options)
     });
   }
+  /** Exported definition for `lunnoa/agents/<slug>.json`. */
+  getDefinition(slug) {
+    return this.http.get(
+      `/api/agents/slug/${encodeURIComponent(slug)}/definition`
+    );
+  }
   /**
    * Upsert an agent by slug inside the workspace on the API key.
    * Prefer the CLI (`npx @lunnoa/client agents deploy`) for happy-path deploy.
    */
   upsertBySlug(body, options) {
     const payload = "kind" in body && body.kind === "agent" ? agentDefinitionToUpsert(body, options) : body;
-    return this.http.post("/api/agents/upsert", {
-      body: payload
-    });
+    return this.http.post(
+      "/api/agents/upsert",
+      { body: payload }
+    );
   }
 };
 
@@ -1843,6 +1966,11 @@ function stepFromDefinition(step) {
       ...step.name ? { name: step.name } : {}
     };
   }
+  if (step.paths?.length) {
+    throw new Error(
+      "runs.start runs straight lines only. Deploy workflows with paths, then execute them."
+    );
+  }
   const use = step.use;
   const input = {
     ...use.input ?? {},
@@ -1860,6 +1988,11 @@ function stepFromDefinition(step) {
 }
 function normalizeStartRunInput(input) {
   if (isWorkflowDefinition(input)) {
+    if ("format" in input && input.format === "graph") {
+      throw new Error(
+        "runs.start runs straight lines only. Push the graph workflow, then execute it."
+      );
+    }
     return {
       steps: input.steps.map(stepFromDefinition),
       name: input.name ?? input.slug
@@ -2051,6 +2184,18 @@ var WorkflowAppsResource = class {
   }
 };
 
+// src/resources/code-sync.ts
+var CodeSyncResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Workspace id and whether synced resources are locked in the UI. */
+  context() {
+    return this.http.get("/api/code-sync/context");
+  }
+};
+
 // src/resources/workflows.ts
 function triggerToUpsertInput(trigger) {
   return {
@@ -2063,8 +2208,38 @@ function triggerToUpsertInput(trigger) {
     ...trigger.description ? { description: trigger.description } : {}
   };
 }
+function asAction(use) {
+  if (use && typeof use === "object" && "kind" in use && use.kind === DEFINE_KINDS.action) {
+    return use;
+  }
+  const fileUse = use;
+  return {
+    kind: DEFINE_KINDS.action,
+    id: fileUse.id,
+    appId: fileUse.appId,
+    connection: fileUse.connection?.id ? { kind: DEFINE_KINDS.connection, id: fileUse.connection.id } : void 0
+  };
+}
+function asTrigger(trigger) {
+  if ("kind" in trigger && trigger.kind === DEFINE_KINDS.trigger) {
+    return trigger;
+  }
+  const fileTrigger = trigger;
+  return {
+    kind: DEFINE_KINDS.trigger,
+    id: fileTrigger.id,
+    appId: fileTrigger.appId,
+    connection: fileTrigger.connection?.id ? { kind: DEFINE_KINDS.connection, id: fileTrigger.connection.id } : void 0,
+    input: fileTrigger.input,
+    inputs: fileTrigger.inputs,
+    name: fileTrigger.name,
+    description: fileTrigger.description
+  };
+}
 function stepToUpsertInput(step) {
-  const use = step.use;
+  const use = asAction(step.use);
+  const retry = "retrySettings" in step ? step.retrySettings : void 0;
+  const continueOnFailure = "continueOnFailure" in step ? step.continueOnFailure : void 0;
   return {
     ...step.key ? { key: step.key } : {},
     appId: resolveActionAppId(use),
@@ -2075,18 +2250,60 @@ function stepToUpsertInput(step) {
       ...step.input ?? {}
     },
     name: step.name ?? use.name,
-    description: use.description
+    description: step.description ?? use.description,
+    ...retry ? { retrySettings: retry } : {},
+    ...continueOnFailure ? { continueOnFailure } : {},
+    ...step.paths?.length ? {
+      paths: step.paths.map((path) => ({
+        label: path.label,
+        ...path.when ? { when: path.when } : {},
+        steps: path.steps.map(
+          (nested) => stepToUpsertInput(nested)
+        )
+      }))
+    } : {}
   };
 }
-function workflowDefinitionToUpsert(def) {
+function syncFields2(options) {
   return {
-    slug: def.slug,
-    name: def.name,
-    description: def.description,
-    isActive: def.isActive,
-    ...def.trigger ? { trigger: triggerToUpsertInput(def.trigger) } : {},
-    managedByCode: true,
-    steps: def.steps.map(stepToUpsertInput)
+    ...options?.baseRevision ? { baseRevision: options.baseRevision } : {},
+    ...options?.force ? { force: true } : {}
+  };
+}
+function workflowDefinitionToUpsert(def, options) {
+  if ("format" in def && def.format === "graph") {
+    return {
+      slug: def.slug,
+      name: def.name,
+      // A file is the whole definition: an omitted description is empty, not "leave it".
+      description: def.description ?? null,
+      codeSource: "synced",
+      graph: { nodes: def.nodes, edges: def.edges ?? [] },
+      ...syncFields2(options)
+    };
+  }
+  if ("format" in def && def.format === "steps") {
+    const file = def;
+    return {
+      slug: file.slug,
+      name: file.name,
+      description: file.description ?? null,
+      ...file.trigger ? { trigger: triggerToUpsertInput(asTrigger(file.trigger)) } : {},
+      codeSource: "synced",
+      steps: file.steps.map((step) => stepToUpsertInput(step)),
+      ...syncFields2(options)
+    };
+  }
+  const authored = def;
+  return {
+    slug: authored.slug,
+    name: authored.name,
+    description: authored.description,
+    isActive: authored.isActive,
+    ...authored.trigger ? { trigger: triggerToUpsertInput(authored.trigger) } : {},
+    codeSource: options?.codeSource ?? "generated",
+    ...syncFields2(options),
+    steps: authored.steps.map((step) => stepToUpsertInput(step))
   };
 }
 var WorkflowsResource = class {
@@ -2111,15 +2328,22 @@ var WorkflowsResource = class {
       query: serializeListQuery(options)
     });
   }
+  /** Exported definition for `lunnoa/workflows/<slug>.json`. */
+  getDefinition(slug) {
+    return this.http.get(
+      `/api/workflows/slug/${encodeURIComponent(slug)}/definition`
+    );
+  }
   /**
    * Upsert a workflow by slug inside the workspace on the API key.
    * Prefer the CLI (`npx @lunnoa/client workflows deploy`) for happy-path deploy.
    */
-  upsertBySlug(body) {
-    const payload = "kind" in body && body.kind === "workflow" ? workflowDefinitionToUpsert(body) : body;
-    return this.http.post("/api/workflows/upsert", {
-      body: payload
-    });
+  upsertBySlug(body, options) {
+    const payload = "kind" in body && body.kind === "workflow" ? workflowDefinitionToUpsert(body, options) : body;
+    return this.http.post(
+      "/api/workflows/upsert",
+      { body: payload }
+    );
   }
   /**
    * Starts a new execution of the workflow with the given trigger inputs.
@@ -2185,6 +2409,8 @@ var LunnoaClient = class {
   aiConnections;
   workflowApps;
   discovery;
+  /** Workspace id for the definitions lock, and the code-sync lock flag. */
+  codeSync;
   constructor(options) {
     this.http = new HttpClient(options);
     this.auth = new AuthResource(this.http, this.http.tokenStore);
@@ -2208,6 +2434,7 @@ var LunnoaClient = class {
     this.connections = new ConnectionsResource(this.http);
     this.aiConnections = new AiConnectionsResource(this.http);
     this.discovery = new DiscoveryResource(this.http);
+    this.codeSync = new CodeSyncResource(this.http);
   }
 };