chore: import upstream snapshot with attribution

apps/sim/tools/langsmith/create_runs_batch.ts

@@ -0,0 +1,113 @@
+import { filterUndefined } from '@sim/utils/object'
+import type {
+  LangsmithCreateRunsBatchParams,
+  LangsmithCreateRunsBatchResponse,
+  LangsmithRunPayload,
+} from '@/tools/langsmith/types'
+import { normalizeLangsmithRunPayload } from '@/tools/langsmith/utils'
+import type { ToolConfig } from '@/tools/types'
+
+export const langsmithCreateRunsBatchTool: ToolConfig<
+  LangsmithCreateRunsBatchParams,
+  LangsmithCreateRunsBatchResponse
+> = {
+  id: 'langsmith_create_runs_batch',
+  name: 'LangSmith Create Runs Batch',
+  description: 'Forward multiple runs to LangSmith in a single batch.',
+  version: '1.0.0',
+  params: {
+    apiKey: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'LangSmith API key',
+    },
+    post: {
+      type: 'json',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Array of new runs to ingest',
+    },
+    patch: {
+      type: 'json',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Array of runs to update/patch',
+    },
+  },
+  request: {
+    url: () => 'https://api.smith.langchain.com/runs/batch',
+    method: 'POST',
+    headers: (params) => ({
+      'X-Api-Key': params.apiKey,
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => {
+      const payload: Record<string, unknown> = {
+        post: params.post
+          ? params.post.map((run) => normalizeLangsmithRunPayload(run).payload)
+          : undefined,
+        patch: params.patch
+          ? params.patch.map((run) => normalizeLangsmithRunPayload(run).payload)
+          : undefined,
+      }
+
+      return filterUndefined(payload)
+    },
+  },
+  transformResponse: async (response, params) => {
+    const data = (await response.json()) as Record<string, unknown>
+    const directMessage =
+      typeof (data as { message?: unknown }).message === 'string'
+        ? (data as { message: string }).message
+        : null
+    const messages = Object.values(data)
+      .map((value) => {
+        if (typeof value !== 'object' || value === null) {
+          return null
+        }
+        const messageValue = (value as Record<string, unknown>).message
+        return typeof messageValue === 'string' ? messageValue : null
+      })
+      .filter((value): value is string => Boolean(value))
+
+    const collectRunIds = (runs?: LangsmithRunPayload[]) =>
+      runs?.map((run) => normalizeLangsmithRunPayload(run).runId) ?? []
+
+    return {
+      success: true,
+      output: {
+        accepted: true,
+        runIds: [...collectRunIds(params?.post), ...collectRunIds(params?.patch)],
+        message: directMessage ?? null,
+        messages: messages.length ? messages : undefined,
+      },
+    }
+  },
+  outputs: {
+    accepted: {
+      type: 'boolean',
+      description: 'Whether the batch was accepted for ingestion',
+    },
+    runIds: {
+      type: 'array',
+      description: 'Run identifiers provided in the request',
+      items: {
+        type: 'string',
+      },
+    },
+    message: {
+      type: 'string',
+      description: 'Response message from LangSmith',
+      optional: true,
+    },
+    messages: {
+      type: 'array',
+      description: 'Per-run response messages, when provided',
+      optional: true,
+      items: {
+        type: 'string',
+      },
+    },
+  },
+}