chore: import upstream snapshot with attribution

apps/sim/tools/temporal/start_workflow.ts

@@ -0,0 +1,171 @@
+import { generateId } from '@sim/utils/id'
+import type {
+  TemporalStartWorkflowParams,
+  TemporalStartWorkflowResponse,
+} from '@/tools/temporal/types'
+import {
+  parseJsonArgs,
+  parseJsonPayloadMap,
+  parseTemporalResponse,
+  TEMPORAL_CLIENT_IDENTITY,
+  temporalRequestHeaders,
+  temporalWorkflowUrl,
+  toDurationString,
+} from '@/tools/temporal/utils'
+import type { ToolConfig } from '@/tools/types'
+
+export const startWorkflowTool: ToolConfig<
+  TemporalStartWorkflowParams,
+  TemporalStartWorkflowResponse
+> = {
+  id: 'temporal_start_workflow',
+  name: 'Temporal Start Workflow',
+  description: 'Start a new workflow execution on a Temporal cluster.',
+  version: '1.0.0',
+
+  params: {
+    serverUrl: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: "Base URL of the Temporal server's HTTP API (e.g., http://localhost:7243)",
+    },
+    namespace: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Temporal namespace (e.g., default)',
+    },
+    apiKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'API key sent as a Bearer token (leave blank for servers without auth)',
+    },
+    workflowId: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Unique workflow ID for the new execution (e.g., order-1234)',
+    },
+    workflowType: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Registered workflow type name to run (e.g., OrderWorkflow)',
+    },
+    taskQueue: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Task queue the workflow worker polls (e.g., orders)',
+    },
+    input: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description:
+        'Workflow input as JSON. A top-level array is passed as the argument list (one argument per element); any other value is passed as a single argument',
+    },
+    workflowIdReusePolicy: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description:
+        'Policy for reusing a closed workflow ID: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE, WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY, WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE, or WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING',
+    },
+    workflowIdConflictPolicy: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description:
+        'Policy when a workflow with the same ID is already running: WORKFLOW_ID_CONFLICT_POLICY_FAIL, WORKFLOW_ID_CONFLICT_POLICY_USE_EXISTING, or WORKFLOW_ID_CONFLICT_POLICY_TERMINATE_EXISTING',
+    },
+    cronSchedule: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Cron schedule for recurring executions (e.g., "0 12 * * *")',
+    },
+    executionTimeoutSeconds: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description:
+        'Total workflow execution timeout in seconds, including retries and continue-as-new',
+    },
+    runTimeoutSeconds: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Timeout for a single workflow run in seconds',
+    },
+    memo: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'JSON object of memo fields to attach to the execution',
+    },
+    searchAttributes: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'JSON object of search attribute values to index the execution with',
+    },
+  },
+
+  request: {
+    url: (params) => temporalWorkflowUrl(params.serverUrl, params.namespace, params.workflowId),
+    method: 'POST',
+    headers: (params) => temporalRequestHeaders(params),
+    body: (params) => {
+      const body: Record<string, unknown> = {
+        workflowType: { name: params.workflowType.trim() },
+        taskQueue: { name: params.taskQueue.trim() },
+        identity: TEMPORAL_CLIENT_IDENTITY,
+        requestId: generateId(),
+      }
+      const input = parseJsonArgs(params.input, 'input')
+      if (input) body.input = input
+      if (params.workflowIdReusePolicy) body.workflowIdReusePolicy = params.workflowIdReusePolicy
+      if (params.workflowIdConflictPolicy) {
+        body.workflowIdConflictPolicy = params.workflowIdConflictPolicy
+      }
+      if (params.cronSchedule) body.cronSchedule = params.cronSchedule
+      const executionTimeout = toDurationString(params.executionTimeoutSeconds)
+      if (executionTimeout) body.workflowExecutionTimeout = executionTimeout
+      const runTimeout = toDurationString(params.runTimeoutSeconds)
+      if (runTimeout) body.workflowRunTimeout = runTimeout
+      const memoFields = parseJsonPayloadMap(params.memo, 'memo')
+      if (memoFields) body.memo = { fields: memoFields }
+      const searchAttributeFields = parseJsonPayloadMap(params.searchAttributes, 'searchAttributes')
+      if (searchAttributeFields) body.searchAttributes = { indexedFields: searchAttributeFields }
+      return body
+    },
+  },
+
+  transformResponse: async (response: Response, params) => {
+    const data = await parseTemporalResponse<{ runId?: string; started?: boolean }>(
+      response,
+      'start workflow'
+    )
+    return {
+      success: true,
+      output: {
+        workflowId: params?.workflowId ?? '',
+        runId: data.runId ?? '',
+        started: data.started ?? false,
+      },
+    }
+  },
+
+  outputs: {
+    workflowId: { type: 'string', description: 'Workflow ID of the execution' },
+    runId: { type: 'string', description: 'Run ID of the started workflow execution' },
+    started: {
+      type: 'boolean',
+      description:
+        'Whether a new execution was started (false when an existing execution was reused)',
+    },
+  },
+}