fix(langsmith,jira,linkedin): correct claims and coercion, align block outputs

The feedback description told the model the official SDK omits session_id.
It does not -- it warns, and raises on SmithDB-only deployments. LangSmith
documents the field as required while only 'key' sits in the OpenAPI
required array; both halves are now stated.

parseLangsmithFeedbackValue was applied in the block and again in
request.body, and it is not idempotent: a quoted "1" became a number and a
quoted "null" dropped the field. The tool body covers every path including
Copilot, so the block call is removed.

Jira declared commentBody and newStatus, which no tool emits, while the
real keys were undeclared; status and assignee are objects declared as
string. LinkedIn's postUrl doc named a URN family the regex never checks.

Author: waleedlatif1

apps/sim/blocks/blocks/jira.ts

@@ -1412,15 +1412,28 @@ Return ONLY the comment text - no explanations.`,
   outputs: {
     // Common outputs across all Jira operations
     ts: { type: 'string', description: 'Timestamp of the operation' },
+    success: { type: 'boolean', description: 'Whether the operation succeeded' },
 
-    // jira_retrieve (read) outputs
+    // jira_retrieve (read) outputs — the transformed issue is spread at the top
+    // level, so every field below sits alongside the raw `issue` object
     issueKey: { type: 'string', description: 'Issue key (e.g., PROJ-123)' },
     summary: { type: 'string', description: 'Issue summary/title' },
     description: { type: 'string', description: 'Issue description content' },
     created: { type: 'string', description: 'Issue creation date' },
     updated: { type: 'string', description: 'Issue last update date' },
-    status: { type: 'string', description: 'Issue status name' },
-    assignee: { type: 'string', description: 'Issue assignee display name or account ID' },
+    status: {
+      type: 'json',
+      description: 'Issue status object with id, name, description, and statusCategory',
+    },
+    statusName: { type: 'string', description: 'Issue status name (e.g., Open, In Progress)' },
+    assignee: {
+      type: 'json',
+      description: 'Assigned user object with accountId, displayName, and emailAddress',
+    },
+    assigneeName: {
+      type: 'string',
+      description: 'Assignee display name or account ID',
+    },
 
     // jira_write (create) outputs
     url: { type: 'string', description: 'URL to the created/accessed issue' },
@@ -1447,8 +1460,11 @@ Return ONLY the comment text - no explanations.`,
 
     // jira_add_comment, jira_update_comment outputs
     commentId: { type: 'string', description: 'Comment ID' },
-    commentBody: { type: 'string', description: 'Comment text content' },
-    author: { type: 'string', description: 'Comment author display name' },
+    body: { type: 'string', description: 'Comment text content' },
+    author: {
+      type: 'json',
+      description: 'Comment author object with accountId, displayName, and emailAddress',
+    },
 
     // jira_get_attachments outputs
     attachments: {
@@ -1478,7 +1494,11 @@ Return ONLY the comment text - no explanations.`,
 
     // jira_transition_issue outputs
     transitionId: { type: 'string', description: 'Applied transition ID' },
-    newStatus: { type: 'string', description: 'New status after transition' },
+    transitionName: { type: 'string', description: 'Applied transition name' },
+    toStatus: {
+      type: 'json',
+      description: 'Target status after transition, with id and name',
+    },
 
     // jira_create_issue_link outputs
     linkId: { type: 'string', description: 'Created link ID' },

apps/sim/blocks/blocks/langsmith.ts

@@ -2,7 +2,6 @@ import { toError } from '@sim/utils/errors'
 import { LangsmithIcon } from '@/components/icons'
 import { AuthMode, type BlockConfig, type BlockMeta, IntegrationType } from '@/blocks/types'
 import type { LangsmithResponse } from '@/tools/langsmith/types'
-import { parseLangsmithFeedbackValue } from '@/tools/langsmith/utils'
 
 export const LangsmithBlock: BlockConfig<LangsmithResponse> = {
   type: 'langsmith',
@@ -421,7 +420,7 @@ Common patch fields: outputs, end_time, status, error`,
             key: params.key,
             sessionId: params.feedback_session_id || params.session_id,
             score: parseScore(params.score),
-            value: parseLangsmithFeedbackValue(params.value),
+            value: params.value,
             comment: params.comment,
             correction: parseJsonValue(params.correction, 'correction'),
             feedbackSourceType: params.feedbackSourceType || undefined,
@@ -476,7 +475,7 @@ Common patch fields: outputs, end_time, status, error`,
     feedback_session_id: {
       type: 'string',
       description:
-        'UUID of the tracing project (session) the feedback belongs to. Optional — LangSmith accepts feedback without it',
+        "UUID of the tracing project (session) the feedback belongs to. LangSmith documents it as required and its SDK warns (or errors, on SmithDB-only deployments) without it. Left optional here so blocks saved against deployments that still resolve the run server-side keep working.",
     },
     session_name: { type: 'string', description: 'Session name' },
     status: { type: 'string', description: 'Run status' },

apps/sim/tools/jira/block_outputs.test.ts

@@ -0,0 +1,65 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { JiraBlock } from '@/blocks/blocks/jira'
+import * as jiraTools from '@/tools/jira'
+import type { ToolConfig } from '@/tools/types'
+
+/**
+ * Output names the block declares for its webhook trigger payload rather than
+ * for a tool result. No Jira tool emits these, by design.
+ */
+const TRIGGER_ONLY_OUTPUTS = new Set([
+  'event_type',
+  'issue_id',
+  'issue_key',
+  'project_key',
+  'project_name',
+  'issue_type_name',
+  'priority_name',
+  'status_name',
+  'assignee_name',
+  'assignee_email',
+  'reporter_name',
+  'reporter_email',
+  'comment_id',
+  'comment_body',
+  'worklog_id',
+  'time_spent',
+  'changelog',
+  'sprint',
+  'version',
+  'jira',
+  'user',
+  'webhook',
+])
+
+const toolOutputNames = new Set<string>()
+for (const tool of Object.values(jiraTools) as ToolConfig[]) {
+  if (!tool?.id?.startsWith('jira_')) continue
+  for (const name of Object.keys(tool.outputs ?? {})) toolOutputNames.add(name)
+}
+
+const declaredOutputs = Object.keys(JiraBlock.outputs ?? {})
+
+describe('jira block outputs match what the tools actually emit', () => {
+  it('reads a non-trivial set of tool outputs', () => {
+    expect(toolOutputNames.size).toBeGreaterThan(20)
+  })
+
+  it('declares no phantom output that no Jira tool ever emits', () => {
+    const phantoms = declaredOutputs.filter(
+      (name) => !TRIGGER_ONLY_OUTPUTS.has(name) && !toolOutputNames.has(name)
+    )
+    expect(phantoms).toEqual([])
+  })
+
+  it.each(['body', 'toStatus', 'transitionName', 'success', 'statusName', 'assigneeName'])(
+    'declares %s, which Jira tools emit',
+    (name: string) => {
+      expect(toolOutputNames.has(name)).toBe(true)
+      expect(declaredOutputs).toContain(name)
+    }
+  )
+})

apps/sim/tools/langsmith/create_feedback.ts

@@ -38,7 +38,7 @@ export const langsmithCreateFeedbackTool: ToolConfig<
       required: false,
       visibility: 'user-or-llm',
       description:
-        'UUID of the tracing project (session) the feedback belongs to. Optional — in the LangSmith OpenAPI spec only `key` is required by POST /api/v1/feedback, and the official SDK sends feedback without a session_id. Supply it when you have it: some LangSmith deployments cannot locate the run without it. Never guess it — use the sessionId reported by a preceding langsmith_get_run for the same run, or look the project up with GET /api/v1/sessions.',
+        'UUID of the tracing project (session) the feedback belongs to. LangSmith documents this as required: "POST /api/v1/feedback now requires a session_id field in the request body. It was previously optional." The official SDK warns when it is omitted and raises outright on SmithDB-only deployments, because some LangSmith deployments cannot locate the run without it. Only `key` is in the endpoint\'s OpenAPI required array, so omitting session_id will not fail request validation — but always supply it when you have it. Never guess it — use the sessionId reported by a preceding langsmith_get_run for the same run, or look the project up with GET /api/v1/sessions.',
     },
     key: {
       type: 'string',

apps/sim/tools/langsmith/langsmith.test.ts

@@ -549,23 +549,29 @@ describe('langsmith feedback session_id documentation', () => {
   })
 })
 
-describe('langsmith feedback session_id is not enforced by LangSmith', () => {
+describe('langsmith feedback session_id documents both halves of the truth', () => {
   const toolDescription = langsmithCreateFeedbackTool.params.sessionId.description ?? ''
   const blockDescription = LangsmithBlock.inputs?.feedback_session_id?.description ?? ''
   const feedbackSessionSubBlock = LangsmithBlock.subBlocks.find(
     (subBlock) => subBlock.id === 'feedback_session_id'
   )
 
-  it('does not tell the model the OpenAPI spec marks session_id as required', () => {
-    expect(toolDescription).not.toMatch(/documents it as required|session_id is required/i)
+  it('never tells the model the SDK omits session_id, which is the failing shape', () => {
+    expect(toolDescription).not.toMatch(/sends feedback without|sdk (?:omits|does not send)/i)
   })
 
-  it('states that only key is required by POST /api/v1/feedback', () => {
-    expect(toolDescription).toMatch(/only `?key`? is required/i)
+  it('says LangSmith documents session_id as required', () => {
+    expect(toolDescription).toMatch(/documents (?:this|it) as required/i)
+    expect(toolDescription).toMatch(/warns|raises/i)
   })
 
-  it('does not claim in the block inputs that LangSmith requires it', () => {
-    expect(blockDescription).not.toMatch(/required by langsmith/i)
+  it('still explains that only key is in the OpenAPI required array', () => {
+    expect(toolDescription).toMatch(/only `?key`? is in the .*required array/i)
+  })
+
+  it('does not claim in the block inputs that LangSmith accepts feedback without it', () => {
+    expect(blockDescription).not.toMatch(/accepts feedback without it/i)
+    expect(blockDescription).toMatch(/documents it as required/i)
   })
 
   it('leaves the feedback Session ID subBlock optional so saved blocks keep validating', () => {
@@ -605,3 +611,51 @@ describe('langsmith batch post/patch shape guard', () => {
     expect((body.post as Record<string, unknown>[])[0]).toMatchObject({ name: 'run-a' })
   })
 })
+
+describe('langsmith feedback value is coerced exactly once', () => {
+  const mapBlockParams = (value: string): Record<string, unknown> =>
+    (
+      LangsmithBlock.tools.config!.params as (p: Record<string, unknown>) => Record<string, unknown>
+    )({
+      operation: 'langsmith_create_feedback',
+      apiKey: 'test-key',
+      runId: 'run-1',
+      key: 'correctness',
+      value,
+    })
+
+  const bodyFromBlock = (value: string): Record<string, unknown> =>
+    resolveBody(
+      langsmithCreateFeedbackTool as never,
+      mapBlockParams(value) as unknown as LangsmithCreateFeedbackParams
+    )
+
+  it.each([
+    ['"1"', '1'],
+    ['"true"', 'true'],
+    ['"null"', 'null'],
+  ])(
+    'leaves a JSON-quoted %s untouched in the block param mapper',
+    (typed: string, _expected: string) => {
+      expect(mapBlockParams(typed).value).toBe(typed)
+    }
+  )
+
+  it.each([
+    ['"1"', '1'],
+    ['"true"', 'true'],
+    ['"null"', 'null'],
+  ])(
+    'keeps a JSON-quoted %s a string on the wire instead of double-coercing it',
+    (typed: string, expected: string) => {
+      const body = bodyFromBlock(typed)
+      expect(body).toHaveProperty('value')
+      expect(body.value).toBe(expected)
+    }
+  )
+
+  it('still coerces an unquoted numeric value exactly once through the block path', () => {
+    expect(bodyFromBlock('1').value).toBe(1)
+    expect(bodyFromBlock('true').value).toBe(true)
+  })
+})

apps/sim/tools/langsmith/types.ts

@@ -114,9 +114,9 @@ export interface LangsmithCreateFeedbackParams {
   key: string
   score?: number
   /**
-   * Declared to the model as `type: 'string'`, but the block's param mapper may
-   * have already coerced it with `parseLangsmithFeedbackValue`, so the runtime
-   * value is any member of the union LangSmith stores — never `null`, which the
+   * Declared to the model as `type: 'string'` and handed to this tool as one:
+   * `parseLangsmithFeedbackValue` runs once, inside `request.body`, widening it
+   * to any member of the union LangSmith stores — never `null`, which the
    * parser drops. The response echoes the full union, `null` included.
    */
   value?: Exclude<LangsmithFeedbackValue, null>

apps/sim/tools/langsmith/utils.ts

@@ -47,7 +47,12 @@ export type LangsmithFeedbackValue = string | number | boolean | Record<string,
  *   throws and the `catch` returns the original string.
  * - An array literal stays a string, since the schema has no array member.
  *
- * Idempotent: a value already coerced by the block layer is returned unchanged.
+ * Not idempotent, and deliberately called exactly once — from
+ * {@link file://./create_feedback.ts}'s `request.body`, which every surface
+ * (block, model tool call, Copilot) routes through. Applying it twice would
+ * unwrap a JSON-quoted string a second time, which is precisely how a user
+ * forces a categorical label that looks scalar: `"1"` would become the number
+ * `1`, `"true"` the boolean `true`, and `"null"` would be dropped entirely.
  */
 export const parseLangsmithFeedbackValue = (value: unknown): LangsmithFeedbackValue | undefined => {
   if (value === undefined || value === null) return undefined

apps/sim/tools/linkedin/share_post.test.ts

@@ -144,15 +144,24 @@ describe('linkedInSharePostTool.outputs', () => {
     expect(Object.keys(linkedInSharePostTool.outputs ?? {}).sort()).toEqual(['postId', 'postUrl'])
   })
 
-  it('names the ugcPost URN family that /v2/ugcPosts actually returns', () => {
-    const descriptions = [
-      linkedInSharePostTool.outputs?.postId?.description ?? '',
-      linkedInSharePostTool.outputs?.postUrl?.description ?? '',
-    ]
-
-    for (const description of descriptions) {
-      expect(description).toContain('ugcPost')
-      expect(description).not.toMatch(/\bshare\b/i)
-    }
+  it('attributes the ugcPost id only to what LinkedIn documents: the create header', () => {
+    const postId = linkedInSharePostTool.outputs?.postId?.description ?? ''
+
+    expect(postId).toContain('x-restli-id')
+    expect(postId).toContain('ugcPost')
+    expect(postId).not.toMatch(/never|always/i)
+  })
+
+  it('does not promise postUrl is gated on the ugcPost family the regex never checks', () => {
+    const postUrl = linkedInSharePostTool.outputs?.postUrl?.description ?? ''
+
+    expect(postUrl).not.toMatch(/ugcPost family/i)
+    expect(postUrl).toContain('urn:li:')
+  })
+
+  it('does not claim postUrl is absent only when postId is', () => {
+    const postUrl = linkedInSharePostTool.outputs?.postUrl?.description ?? ''
+
+    expect(postUrl).toMatch(/or did not carry/i)
   })
 })

apps/sim/tools/linkedin/share_post.ts

@@ -176,13 +176,13 @@ export const linkedInSharePostTool: ToolConfig<SharePostParams, SharePostRespons
     postId: {
       type: 'string',
       description:
-        'The `urn:li:ugcPost:` URN of the created post, read from the `x-restli-id` response header. Absent when LinkedIn omits that header.',
+        'The URN of the created post, read from the `x-restli-id` response header, which LinkedIn documents as carrying the ugcPost id. Reported as received. Absent when LinkedIn omits that header.',
       optional: true,
     },
     postUrl: {
       type: 'string',
       description:
-        'LinkedIn URL of the created post. Viewable by an authorized LinkedIn member — not a guaranteed public permalink. Absent when the `x-restli-id` header was missing or did not carry a `urn:li:` URN of the ugcPost family.',
+        'LinkedIn URL of the created post. Viewable by an authorized LinkedIn member — not a guaranteed public permalink. Absent when the `x-restli-id` header was missing or did not carry a `urn:li:<entityType>:<id>` URN.',
       optional: true,
     },
   },

apps/sim/tools/linkedin/types.ts

@@ -43,15 +43,19 @@ export interface SharePostParams {
 export interface SharePostResponse extends ToolResponse {
   output: {
     /**
-     * The `urn:li:ugcPost:` URN of the created post, from the `x-restli-id` response header;
-     * absent if LinkedIn omits the header. `/v2/ugcPosts` returns a ugcPost URN, never a
-     * `urn:li:share:` URN from the legacy Shares API.
+     * The URN of the created post, from the `x-restli-id` response header; absent if LinkedIn
+     * omits the header. LinkedIn documents the create response's `x-restli-id` as carrying the
+     * ugcPost id. It is not a guarantee about every id `/v2/ugcPosts` ever hands back: the
+     * finder examples in the same reference return `urn:li:share:` ids for existing posts, so
+     * the value is reported as received rather than assumed to be a `urn:li:ugcPost:` URN.
      */
     postId?: string
     /**
      * LinkedIn's `feed/update/<urn>` permalink for the created post. LinkedIn documents this URL
      * as viewable by an authorized member, so it is not guaranteed to resolve for the public or
-     * for signed-out visitors. Absent whenever {@link SharePostResponse.output.postId} is.
+     * for signed-out visitors. Absent whenever {@link SharePostResponse.output.postId} is, and
+     * also when `postId` is present but is not shaped like a `urn:li:` URN — the header is
+     * server-controlled, so it is only interpolated into a URL after that check.
      */
     postUrl?: string
   }