NodaroAccount
Docs do Nodaro
DocumentaçãoReferência de nósModelosTemplatesAgentes de IA (MCP)DesenvolvedoresAuto-hospedagemPesquisaComparações
SDK para TypeScript

Workflows e projetos

Crie, atualize, compartilhe, exporte, importe e execute workflows do Nodaro em TypeScript com client.workflows e agrupe-os em projetos com client.projects.

client.workflows lê, grava, compartilha e executa workflows do Nodaro, e client.projects gerencia os projetos que os contêm. client.sessions agrupa gerações avulsas em sessões dentro de um projeto. Um workflow é um canvas de nós conectados, e todo workflow pertence a um projeto. Os métodos chamam os mesmos endpoints da API REST de workflows. Veja Workflows e projetos para os conceitos.

Métodos

MétodoO que faz
workflows.list(params)Lista os workflows de um projeto, sem os grafos deles
workflows.get(id)Lê um workflow com os nós, as conexões e as configurações dele
workflows.getPublic(id)Lê um workflow compartilhado por link, sem token
workflows.create(input)Cria um workflow em um projeto
workflows.update(id, input)Altera quaisquer campos de um workflow
workflows.delete(id)Exclui um workflow
workflows.run(id, params?)Inicia uma execução do workflow
workflows.renderFinal(id, params)Faz a renderização final de uma renderização do Aplicar EDL depois que a prévia foi revisada
workflows.estimateRenderFinal(id, params)Faz a cotação dessa renderização final antes de iniciá-la
workflows.export(workflowId, opts?)Exporta um workflow como um pacote JSON portátil
workflows.import(input)Importa um pacote para um projeto
workflows.setVisibility(id, visibility)Torna um workflow privado ou visível para o espaço de trabalho dele
workflows.move(id, params)Move um workflow para outro projeto
workflows.sharedWithMe()Lista os workflows que outras pessoas compartilharam com você
workflows.listMcpConversations(params?)Lista as suas conversas MCP de um mês
workflows.collaborators.*Lista, adiciona, altera e remove as pessoas com quem um workflow é compartilhado
projects.list() e outrosLista, lê, cria, atualiza e exclui projetos
sessions.create(input) e outrosSessões de geração dentro de um projeto, e as tarefas que elas contêm

client.workflows

list(params)

Lista os workflows de um projeto. A lista retorna só metadados: nodes, edges, settings e sourcePrompt ficam de fora. Leia um workflow com get() para obter o grafo completo dele.

list(params: { projectId: string }): Promise<{ data: Workflow[] }>

Propriedade

Tipo

const { data: workflows } = await client.workflows.list({ projectId })
for (const wf of workflows) console.log(wf.id, wf.name, wf.updatedAt)

Lança NotFoundError quando o projeto não está visível para você.

get(id)

Lê um workflow, incluindo nodes, edges e settings completos.

get(id: string): Promise<{ data: Workflow }>

Propriedade

Tipo

const { data: wf } = await client.workflows.get(workflowId)
console.log(`${wf.name}: ${wf.nodes?.length ?? 0} nodes, version ${wf.version}`)

Guarde a version se você pretende atualizar o workflow: ela torna a atualização segura contra outras pessoas que também gravam nele.

getPublic(id)

Lê um workflow que o dono compartilhou por link (GET /v1/public/workflows/:id). Não é preciso token. O workflow só é retornado enquanto o compartilhamento dele estiver ativado; caso contrário, o método lança NotFoundError. Um vídeo UGC volta para qualquer pessoa que não seja o dono como um app publicado o entrega: os nós UGC dele, e todos os nós feitos a partir deles, sem os resultados, e nunca com a foto do dono. Em uma implantação que não permite trabalhos públicos (outputs.allowPublic: false), o método lança NotFoundError para todos, exceto o dono do workflow com login, como para um workflow que não está compartilhado.

getPublic(id: string): Promise<{ data: Workflow }>

Propriedade

Tipo

const { data: shared } = await client.workflows.getPublic(workflowId)

Quando o provedor de autenticação não retorna nenhum token, a requisição é enviada sem token.

Uma produção do Studio compartilhada volta sem o estado de trabalho do dono. A lixeira, as execuções em andamento, os espaços de mídia vazios e o rascunho não salvo do editor ficam fora de settings.studio.

create(input)

Cria um workflow em um projeto e retorna o registro completo. Só projectId e name são necessários; os outros campos usam os padrões do servidor.

create(input: CreateWorkflowInput): Promise<{ data: Workflow }>

Propriedade

Tipo

const { data: wf } = await client.workflows.create({
  projectId,
  name: "Product launch video",
  nodes: [],
  edges: [],
})

Para obter um grafo pronto, exporte um workflow que você montou no editor e leia os nodes e edges dele, ou clone um template.

update(id, input)

Altera qualquer subconjunto dos campos de um workflow e retorna o registro completo atualizado (PATCH /v1/workflows/:id). Os campos que você deixa de fora continuam como estão.

update(id: string, input: UpdateWorkflowInput): Promise<{ data: Workflow }>

Propriedade

Tipo

await client.workflows.update(workflowId, { name: "Renamed", expectedVersion: 7 })

Atualizações seguras. Sem expectedVersion ou expectedUpdatedAt, a última gravação prevalece. Com um deles, a atualização só é aplicada se ninguém tiver alterado o workflow desde que você o leu. Caso contrário, ela lança WorkflowConflictError, cujo currentRecord contém o workflow atual para que você possa mesclar sem uma nova leitura:

import { WorkflowConflictError } from "@nodaro/sdk"

try {
  await client.workflows.update(workflowId, { settings, expectedVersion: wf.version })
} catch (err) {
  if (err instanceof WorkflowConflictError && err.currentRecord) {
    const merged = mergeSettings(err.currentRecord.settings, settings)
    await client.workflows.update(workflowId, {
      settings: merged,
      expectedVersion: err.currentVersion,
    })
  } else {
    throw err
  }
}

Os valores de estado de execução nos dados dos nós, como o status de execução ou o ID da tarefa atual, são removidos pelo servidor e nunca são salvos.

delete(id)

Exclui um workflow.

delete(id: string): Promise<{ success: true }>

Propriedade

Tipo

await client.workflows.delete(workflowId)

Lança NotFoundError quando o ID não existe ou não é seu; assim, uma exclusão nunca falha em silêncio.

run(id, params?)

Inicia uma execução do workflow e retorna na hora com { executionId, status }. A execução continua no servidor. Consulte client.executions.get() periodicamente para acompanhar o progresso e o resultado.

run(id: string, params?: {
  nodeIds?: string[]
  inputOverrides?: Record<string, Record<string, unknown>>
  continueFromExecutionId?: string
  continueMode?: "from-failed"
}, options?: { idempotencyKey?: string }): Promise<{ executionId: string; status: "pending" | "running" }>

Propriedade

Tipo

const { executionId } = await client.workflows.run(workflowId, {
  nodeIds: ["text-prompt-1", "image-gen-2"],
})
const { data: execution } = await client.executions.get(executionId)
  • Lança InsufficientCreditsError quando a conta não consegue cobrir o maior custo possível da execução.
  • Enquanto uma execução deste workflow ainda está em andamento, uma nova lança um AlreadyRunningError (409 already_running). O executionId dele é a execução a acompanhar.
  • Um token OAuth precisa do escopo workflows:execute.
  • Para executar um workflow em um espaço de trabalho, chame run em um cliente obtido com client.withWorkspace().

Continuar uma execução anterior. Com continueFromExecutionId, só os nós de nodeIds são executados. Todos os outros nós repassam o que a execução anterior produziu, nunca os resultados salvos do workflow. Um nó Plano de edição repassa o plano com a sua revisão atual aplicada. Os inputOverrides da execução anterior são aplicados de novo, e os que você envia agora são aplicados por cima deles, campo a campo.

await client.workflows.run(workflowId, {
  nodeIds: [renderNodeId, captionsNodeId],
  inputOverrides: { [renderNodeId]: { quality: "final" } },
  continueFromExecutionId: previewRunId,
})

Uma continuação recusada lança um erro antes de qualquer execução existir. Quando a execução anterior não é encontrada: NotFoundError com o código continuation_not_found. Caso contrário, um NodaroError cujo code é continuation_subset_required (sem nodeIds), continuation_workflow_mismatch, continuation_version_mismatch ou continuation_not_completed.

Continuar uma execução que falhou. Com continueMode: "from-failed", continueFromExecutionId é uma execução sua do workflow que falhou, e a execução continua de onde ela parou. Só os nós que essa execução não concluiu são executados: o que ela concluiu é repassado, nunca executado nem cobrado de novo. Um nó que falhou é executado de novo por inteiro. nodeIds é opcional: sem ele, a execução é continuada nos nós em que foi iniciada, mais cada nó que ficou com falha ou foi segurado. client.executions.get(id) indica em nodeScope os nós em que a primeira execução foi iniciada (null significa todos os nós). Todo ID em nodeIds conta como indicado: um nó de trabalho que nenhuma execução da cadeia executou é executado e cobrado. Um nó que foi executado em qualquer execução da cadeia nunca é executado de novo por ser indicado. Uma fonte ou um upload, um gatilho, um seletor ou um contêiner Grupo ou Coletar repassa o que a execução repassou, e um nó definido para ser pulado nunca é executado. Envie uma idempotencyKey, para que uma nova tentativa da mesma chamada não inicie nada novo.

await client.workflows.run(
  workflowId,
  { continueFromExecutionId: failedRunId, continueMode: "from-failed" },
  { idempotencyKey: crypto.randomUUID() }, // reuse the same key when you retry this call
)
  • Uma execução que uma continuação mais recente substitui lança um NodaroError com o código continuation_superseded. A mensagem dele indica essa continuação: continue essa, ou encontre os resultados dela ali quando ela concluiu tudo.
  • Quando a continuação mais recente parou em uma revisão de prévia, a chamada lança um ContinuationPreviewPendingError (código continuation_preview_pending, exportado de @nodaro/sdk/errors). O next dele é a execução que conclui a revisão: envie client.workflows.run(workflowId, error.next) antes e depois continue.
  • Uma execução que não falhou lança continuation_not_failed. Uma execução sem nada restante lança continuation_subset_required.
  • Uma continuação que seus créditos não cobrem lança InsufficientCreditsError antes de qualquer execução existir.

Veja Continuar uma execução que falhou para todas as regras.

Em uma instalação em que uma prévia pausa a execução para revisão, a execução de um workflow cuja renderização do Aplicar EDL está definida como prévia é recusada com 400 preview_review_required, porque ninguém revisa uma execução do SDK. Defina a renderização como Final para essa execução com inputOverrides: { [renderNodeId]: { quality: "final" } }. No Nodaro Cloud, uma execução não para em uma prévia, então essa recusa não acontece.

renderFinal(id, params)

Faz a renderização final de uma renderização do Aplicar EDL que produziu uma prévia, depois que você a revisou. Executa o mesmo que o botão Renderização final do editor: a renderização em Final só nesta execução e, depois, todos os nós seguintes. O nó mantém a própria Qualidade. Quando o Troca de câmeras fica entre o Plano de edição e a renderização, o Troca de câmeras é executado de novo primeiro.

renderFinal(id: string, params: { renderNodeId: string; continueFromExecutionId: string }): Promise<{ executionId: string; status: "pending" | "running" }>

Propriedade

Tipo

O servidor decide quais nós são executados, pela mesma regra do editor, então você envia só a renderização e a execução anterior. Todo nó que não é executado repassa o que a execução anterior produziu.

const { executionId } = await client.workflows.renderFinal(workflowId, {
  renderNodeId,
  continueFromExecutionId: previewRunId,
})
  • Um ID de nó que não existe é recusado com render_final_node_not_found, e um nó que não é uma renderização do Aplicar EDL, com render_final_not_a_render. Os códigos de continuação de run() também se aplicam.
  • Uma execução que o pagador não consegue cobrir lança InsufficientCreditsError (402) antes de qualquer execução existir, com required e available.
  • Um token OAuth precisa do escopo workflows:execute.

estimateRenderFinal(id, params)

Faz a cotação de um renderFinal() e não cria nada. Recebe os mesmos parâmetros.

estimateRenderFinal(id: string, params: { renderNodeId: string; continueFromExecutionId: string }): Promise<{ data: RenderFinalQuote }>
const { data: quote } = await client.workflows.estimateRenderFinal(workflowId, {
  renderNodeId,
  continueFromExecutionId: previewRunId,
})
if (quote.sufficient) {
  await client.workflows.renderFinal(workflowId, { renderNodeId, continueFromExecutionId: previewRunId })
}

Um RenderFinalQuote tem renderNodeId, nodeIds (os nós que serão executados), inputOverrides (a substituição usada na execução), estimatedCredits, holdCredits, sufficient e available. holdCredits é o que a execução reserva enquanto renderiza: um clipe UGC pela reserva dele, cerca do dobro do preço, e nunca abaixo da estimativa. sufficient diz se o pagador consegue cobrir essa reserva, e available são os créditos que o pagador pode gastar. available é null quando um orçamento de espaço de trabalho paga. Os valores são null em uma edição sem créditos. Quando a execução roda um nó de LLM, a cotação acrescenta estimatedCreditsIsEstimate: true: esse nó é cobrado pelo uso real, então mostre o valor como ≈N.

export(workflowId, opts?)

Exporta a versão salva de um workflow como um pacote JSON portátil, o formato de arquivo que o menu Exportar do editor grava. Com assets: true, o pacote também leva as entidades que o workflow usa, como Com mídias no editor.

export(workflowId: string, opts?: { assets?: boolean }): Promise<{ data: WorkflowExport }>

Propriedade

Tipo

const { data: bundle } = await client.workflows.export(workflowId, { assets: true })

Portabilidade. Um pacote só pode apontar para mídias que outra instância consiga buscar. Quando os nós usam URLs que outras instâncias não conseguem acessar, como o armazenamento próprio de uma instalação auto-hospedada em localhost, um endereço de rede local ou um nome .internal, o pacote lista essas URLs em portability.unreachableMedia:

bundle.portability?.unreachableMedia
// [{ nodeId: "n1", nodeLabel: "Video URL", field: "videoUrl", url: "http://localhost:3000/storage/..." }]

O campo não aparece quando todas as URLs de mídia são públicas. Um pacote assim ainda pode ser importado, mas esses nós não podem ser executados na outra instância até que as mídias sejam enviadas para lá de novo. Veja Importação e exportação.

import(input)

Importa um pacote exportado para um dos seus projetos e retorna o novo workflow.

import(input: WorkflowExport & { projectId: string }): Promise<{
  data: Workflow
  importReport?: WorkflowImportReport
}>

Propriedade

Tipo

const { data: wf, importReport } = await client.workflows.import({ ...bundle, projectId })

O que a importação faz:

  • As entidades são recriadas. Os personagens, objetos, criaturas e locais do pacote viram novos itens na sua conta. O workflow passa a apontar para eles nos nós de entidade, em cada menção com @ nos dados dos nós e nas configurações do workflow.
  • As mídias são copiadas. As mídias em outros hosts são copiadas para o armazenamento desta instância quando podem ser acessadas; assim, o workflow não depende do servidor de outra pessoa. Os limites são 25 arquivos para as mídias do workflow e mais 25 para as entidades do pacote, com imagens de até 20 MB e vídeo ou áudio de até 50 MB.
  • As cópias contam no seu armazenamento. Quando o armazenamento acaba, o workflow ainda é importado, e as entidades que não couberam são listadas no relatório.

O importReport informa o que aconteceu:

importReport
// {
//   rehosted: 3,                                    // files copied to this instance
//   unreachable: [{ nodeId, nodeLabel, field, url }], // private hosts, left as they were
//   skipped: [{ nodeId, field, url, reason: "HTTP 404" }],
//   assetIdMap: { "<bundled asset id>": "<new asset id>" },
//   assetsSkipped: [{ kind: "character", id, name: "Kira", reason: "Storage limit exceeded" }],
// }

assetIdMap está presente sempre que o pacote trouxe entidades. O servidor já atualizou todas as menções dentro do workflow. Use o mapa só para referências que você guarda fora dele. assetsSkipped só aparece quando algo ficou de fora.

setVisibility(id, visibility)

Torna um workflow "private", visível para quem o criou e para os colaboradores que você adicionar, ou "workspace", visível para todos no espaço de trabalho dele.

setVisibility(id: string, visibility: "private" | "workspace"): Promise<{ data: Workflow }>

Propriedade

Tipo

await client.workflows.setVisibility(workflowId, "workspace")

Só quem criou o workflow ou um administrador do espaço de trabalho pode mudar isso; qualquer outra pessoa recebe ForbiddenError. Os espaços de trabalho existem nas organizações do Nodaro Cloud.

move(id, params)

Move um workflow para outro projeto (POST /v1/workflows/:id/move). O workflow sai da pasta em que estava.

move(id: string, params: { projectId: string }): Promise<{
  data: Workflow
  droppedCollaborators: { userId: string; name: string | null }[]
}>

Propriedade

Tipo

const { droppedCollaborators } = await client.workflows.move(workflowId, { projectId: archiveProjectId })

Quando a mudança tira o workflow de um espaço de trabalho, o acesso que vinha desse espaço de trabalho termina. Essas pessoas são retornadas em droppedCollaborators.

sharedWithMe()

Lista os workflows que outras pessoas compartilharam diretamente com você. O que está em um espaço de trabalho do qual você faz parte não é incluído, porque já aparece nas listas desse espaço de trabalho. Cada workflow traz o grantedRole que você tem nele.

sharedWithMe(): Promise<{ data: (Workflow & { grantedRole: "viewer" | "editor" })[] }>
const { data: shared } = await client.workflows.sharedWithMe()
for (const wf of shared) console.log(wf.name, wf.grantedRole)

A lista fica vazia em instâncias sem organizações.

listMcpConversations(params?)

Lista as suas conversas MCP de um mês, das mais recentes para as mais antigas, por meio de GET /v1/mcp-conversations. Cada conversa é um workflow que um assistente montou a partir das etapas dele. Veja As conversas MCP viram workflows.

listMcpConversations(params?: { month?: string; sources?: string[] }): Promise<McpConversationList>
  • month é "YYYY-MM". O padrão é o mês mais recente que tem conversas.
  • sources mantém só algumas origens, por exemplo "claude", "claude-code" ou "chatgpt".

O resultado traz month, months (todos os meses que têm conversas, com a contagem de cada um), sources (as origens do mês, com as conexões que cada uma reúne) e data, um McpConversation[]. Uma conversa é um workflow: abra-a com get(conversation.id).

const { data, months } = await client.workflows.listMcpConversations({ month: "2026-10", sources: ["claude-code"] })

collaborators

As pessoas com quem um workflow é compartilhado, acessadas como client.workflows.collaborators. Estes métodos existem em instâncias com organizações; nas outras, eles lançam NotFoundError.

collaborators.list(workflowId: string): Promise<{ data: Collaborator[] }>
collaborators.add(workflowId: string, input: { userId?: string; email?: string; role: "viewer" | "editor" }): Promise<{ data: { userId: string; role: "viewer" | "editor" } }>
collaborators.update(workflowId: string, userId: string, input: { role: "viewer" | "editor" }): Promise<{ data: { userId: string; role: "viewer" | "editor" } }>
collaborators.remove(workflowId: string, userId: string): Promise<{ success: true }>

Propriedade

Tipo

await client.workflows.collaborators.add(workflowId, { email: "editor@example.com", role: "editor" })

const { data: people } = await client.workflows.collaborators.list(workflowId)
// [{ userId, name, avatar, role }]: email addresses are never returned

Um colaborador pode chamar remove() com o próprio ID de usuário para sair de um workflow.

client.projects

Um projeto agrupa workflows. Todo workflow pertence a exatamente um projeto.

projects.list()

Lista seus projetos.

list(): Promise<{ data: Project[] }>
const { data: projects } = await client.projects.list()

projects.get(id)

Lê um projeto.

get(id: string): Promise<{ data: Project }>

Propriedade

Tipo

const { data: project } = await client.projects.get(projectId)

projects.create(input)

Cria um projeto.

create(input: { name: string; description?: string; settings?: Record<string, unknown> }): Promise<{ data: Project }>

Propriedade

Tipo

const { data: project } = await client.projects.create({ name: "Spring campaign" })

projects.update(id, input)

Altera um projeto. Passe pelo menos um campo.

update(id: string, input: { name?: string; description?: string; settings?: Record<string, unknown> }): Promise<{ data: Project }>

Propriedade

Tipo

await client.projects.update(projectId, { description: "Assets for the spring launch" })

projects.delete(id)

Exclui um projeto.

delete(id: string): Promise<{ success: true }>

Propriedade

Tipo

await client.projects.delete(projectId)

client.sessions

Uma sessão de geração agrupa gerações avulsas dentro de um projeto, igual em todos os dispositivos. Um projeto contém as suas sessões, e cada sessão contém os seus itens. O projeto de uma sessão é definido quando você a cria. Cada item é um link para uma das suas tarefas, não uma cópia.

const { data: session } = await client.sessions.create({ projectId, tool: "create-image", title: "Beach" })

// A job joins a session when the generation request names it.
await client.nodes.runAndWait("generate-image", {
  prompt: "a red car",
  sessionId: session.id,
  origin: "create-image",
})

const { data: sessions, next } = await client.sessions.list({ projectId })
const { data: items } = await client.sessions.items(session.id)
MétodoAssinaturaObservações
createcreate(input: CreateSessionInput): Promise<{ data: GenerationSession }>tool é obrigatório, por exemplo create-image. projectId e title são opcionais.
listlist(params?: ListSessionsParams): Promise<SessionPage<GenerationSession>>Das mais novas para as mais antigas. Filtros: projectId ("none" para as sessões sem projeto), tool, includeArchived, limit, cursor. Cada sessão traz itemCount (itens ativos), removedCount (itens na Lixeira), coverJobId e até quatro previewUrls (primeiro a imagem da capa, quando há uma definida).
getget(id: string): Promise<{ data: GenerationSession }>Uma sessão.
updateupdate(id: string, input: UpdateSessionInput): Promise<{ data: GenerationSession }>title (null a deixa sem título), archived e coverJobId (um dos itens da sessão, 404 caso contrário; null significa automático). O projeto não pode mudar.
deletedelete(id: string): Promise<{ success: true }>Exclui a sessão. As tarefas dela são mantidas e continuam em todas as outras sessões que as contêm.
itemsitems(id: string, params?: ListSessionItemsParams): Promise<SessionPage<SessionItem>>O feed ativo, dos mais novos para os mais antigos. Cada item tem jobId, addedAt, removedAt, imported, importedFrom e job. { removed: true } lista em vez disso os itens removidos da sessão, a Lixeira dela, da remoção mais recente para a mais antiga.
importItemsimportItems(id: string, input: { jobIds: string[] }): Promise<{ data: { imported: number; requested: number } }>Vincula até 100 tarefas ativas suas à sessão. É tudo ou nada: uma tarefa que não é sua faz a chamada falhar com 404. Um item removido da sessão volta para onde estava.
moveItemsmoveItems(targetId: string, input: MoveSessionItemsInput): Promise<{ data: { moved: number } }>{ jobIds, fromSessionId }, em uma só transação. O destino recebe os itens, e a origem os mantém como itens removidos, então restoreItem(fromSessionId, jobId) desfaz a movimentação. É tudo ou nada: 404 quando algum ID não é um item ativo da origem.
removeItemremoveItem(id: string, jobId: string, options?: { forever?: boolean }): Promise<{ success: true }>Envia o item para a Lixeira da sessão até ele ser restaurado. Nada é limpo automaticamente. A tarefa, e todas as outras sessões que a contêm, continuam. { forever: true } exclui permanentemente um item que já foi removido, e lança um NodaroError 409 not_in_trash em um item ativo.
restoreItemrestoreItem(id: string, jobId: string): Promise<{ success: true }>Traz um item removido de volta à sessão, para onde ele estava.

O projeto de uma sessão é fixo, então mover itens para uma sessão de outro projeto é como eles mudam de projeto: chame moveItems() em uma sessão de lá. Um item que nenhuma sessão contém mais aparece em Geral: client.jobs.list({ inSession: false }).

client.trash

A Lixeira guarda os itens que você removeu das sessões e as tarefas que você excluiu. Uma ferramenta de criação a mostra como uma entrada ao lado de Geral. Veja A Lixeira.

list(params?: ListTrashParams): Promise<TrashPage> // GET /v1/trash

interface ListTrashParams {
  projectId?: string | "none" // a project, or the sessions with no project and General
  tool?: string               // what a session of this tool holds or held
  type?: string | string[]    // input_data.type, like jobs.list
  limit?: number              // 1–100 (default 50)
  cursor?: string             // the previous page's next
}

type TrashEntry =
  | { kind: "removed"; removedAt: string; session: TrashSession; job: Job }
  | { kind: "deleted"; deletedAt: string; purgeAt: string; job: Job }

A lista vai da entrada mais recente para a mais antiga. Um item removido fica até sessions.restoreItem(session.id, job.id) ou sessions.removeItem(session.id, job.id, { forever: true }). Uma tarefa excluída fica até purgeAt, 30 dias depois de deletedAt, e então é excluída permanentemente. Uma cópia salva na Biblioteca continua lá. jobs.restore(job.id) a traz de volta para todas as sessões em que ela estava, e jobs.delete(job.id, { forever: true }) a exclui agora. Um item removido cuja tarefa você também excluiu aparece uma só vez, como a tarefa excluída. Uma tarefa que nunca esteve em uma sessão não tem ferramenta, então tool a deixa de fora: passe type, com os tipos de tarefa da sua ferramenta, para incluí-la.

const { data: trash } = await client.trash.list({ projectId, type: ["generate-image", "image-edit"] })
for (const entry of trash) {
  if (entry.kind === "deleted") await client.jobs.restore(entry.job.id)
  else await client.sessions.restoreItem(entry.session.id, entry.job.id)
}

Toda requisição que cria uma tarefa aceita sessionId e origin, e a plataforma os registra na tarefa. Eles estão tipados em todos os tipos de parâmetros de geração, como GenerateImageParams, GenerateVideoParams e TextToSpeechParams, e nas entradas generate* de personagens, objetos, locais e criaturas. origin precisa ser um slug: letras minúsculas, dígitos e hifens, no máximo 40 caracteres. Qualquer outro valor falha com 400 validation_error. O session_id de uma tarefa aparece em client.jobs.get() e em client.jobs.list().

Tipos

TipoFormato
Workflowid, projectId, userId, name, description?, folderId?, version?, thumbnailUrl?, nodes?, edges?, settings?, sourcePrompt?, createdAt, updatedAt. Os campos do grafo só aparecem em registros completos.
RunWorkflowParamsnodeIds?, inputOverrides?, continueFromExecutionId?
RenderFinalParamsrenderNodeId, continueFromExecutionId
RenderFinalQuoterenderNodeId, nodeIds, inputOverrides, estimatedCredits, estimatedCreditsIsEstimate?, holdCredits, sufficient, available
Projectid, userId, name, description?, settings?, createdAt, updatedAt
GenerationSession, SessionItem, SessionPageUma sessão de geração, um dos itens dela e uma página de qualquer um dos dois
CollaboratoruserId, name?, avatar?, role
WorkflowExportO pacote portátil que export() retorna e import() aceita
GenericNode, GenericEdgeOs formatos de nó e de conexão usados em nodes e edges

Todos eles são exportados de @nodaro/sdk. Veja Tipos.

Perguntas frequentes

Como executo um workflow do Nodaro pelo código?

Chame client.workflows.run(workflowId). O método retorna um executionId na hora. Consulte client.executions.get(executionId) periodicamente até o status ser completed, failed, cancelled ou timed_out.

Posso executar só alguns nós de um workflow?

Sim. Passe um objeto com nodeIds, a lista de IDs dos nós a executar, como segundo argumento de client.workflows.run. Só esses nós são executados.

Como faço a renderização final de uma prévia pelo código?

Chame client.workflows.renderFinal com o ID do nó de renderização do Aplicar EDL e o ID da execução que produziu a prévia. O método renderiza em Final e executa todos os nós depois da renderização. client.workflows.estimateRenderFinal faz a cotação antes.

Como evito sobrescrever as alterações de outra pessoa?

Passe expectedVersion, a versão que você leu, para client.workflows.update. Se o workflow mudou nesse meio-tempo, a chamada lança WorkflowConflictError com o registro atual; assim, você pode mesclar e tentar de novo.

Como copio um workflow para outra instância do Nodaro?

Exporte-o com client.workflows.export e a opção assets definida como true. Depois, importe o pacote na outra instância com client.workflows.import e um projectId. As mídias acessíveis são copiadas para o armazenamento da nova instância.

Última atualização

Nesta página