fix(managed-agents): route memory via metadata on self-hosted environments

Live API testing revealed self-hosted environments reject the `resources`
array with a 400 ("resources are not supported with self-hosted
environments"), so the prior universal-resources[] payload would have failed
any self-hosted session that attached a memory store or files.

Restore env-type-aware routing: resolve the environment's config.type via a new
getEnvironmentType() before session create, and for self_hosted send the memory
store through metadata.memory_store_ids/memory_access (the worker consumes it)
and drop file attachments. Cloud environments keep resources[]. Verified end-to-
end against the live Managed Agents API (cloud resources[] 200, self-hosted
metadata 200, self-hosted resources[] 400).

Author: waleedlatif1

apps/sim/lib/managed-agents/run-session.test.ts

@@ -12,6 +12,7 @@ const { mocks } = vi.hoisted(() => ({
     openSessionStream: vi.fn(),
     listSessionEvents: vi.fn(),
     getSession: vi.fn(),
+    getEnvironmentType: vi.fn(),
     interruptSession: vi.fn(),
     readSSEEvents: vi.fn(),
     sleep: vi.fn(),
@@ -25,6 +26,7 @@ vi.mock('@/lib/managed-agents/session-client', () => ({
   openSessionStream: mocks.openSessionStream,
   listSessionEvents: mocks.listSessionEvents,
   getSession: mocks.getSession,
+  getEnvironmentType: mocks.getEnvironmentType,
   interruptSession: mocks.interruptSession,
 }))
 vi.mock('@/lib/core/utils/sse', () => ({ readSSEEvents: mocks.readSSEEvents }))
@@ -72,6 +74,7 @@ beforeEach(() => {
   mocks.openSessionStream.mockResolvedValue({})
   mocks.listSessionEvents.mockResolvedValue([])
   mocks.getSession.mockResolvedValue(null)
+  mocks.getEnvironmentType.mockResolvedValue('cloud')
   mocks.interruptSession.mockResolvedValue(undefined)
 })
 

apps/sim/lib/managed-agents/run-session.ts

@@ -6,6 +6,7 @@ import {
   type AnthropicSessionEvent,
   type CreateSessionInput,
   createSession,
+  getEnvironmentType,
   getSession,
   interruptSession,
   listSessionEvents,
@@ -103,10 +104,20 @@ export async function runManagedAgentSession(
   const userMessage = input.userMessage.trim()
   if (!userMessage) return { ok: false, content: '', error: 'User message is required.' }
 
+  // Resolve the environment type up front so the payload routes correctly:
+  // self-hosted environments reject `resources`, so memory must go via metadata
+  // there. Best-effort — an undefined result falls back to cloud behavior.
+  const environmentType = await getEnvironmentType({
+    apiKey,
+    environmentId: input.environmentId,
+    signal,
+  })
+
   const createInput: CreateSessionInput = {
     apiKey,
     agentId: input.agentId,
     environmentId: input.environmentId,
+    ...(environmentType ? { environmentType } : {}),
     ...(input.title ? { title: input.title } : {}),
     ...(input.vaultIds && input.vaultIds.length > 0 ? { vaultIds: input.vaultIds } : {}),
     ...(input.memoryStoreId ? { memoryStoreId: input.memoryStoreId } : {}),

apps/sim/lib/managed-agents/session-client.test.ts

@@ -110,7 +110,7 @@ describe('buildSessionCreatePayload — metadata', () => {
     expect(buildSessionCreatePayload({ ...BASE, sessionParameters: {} }).metadata).toBeUndefined()
   })
 
-  it('keeps memory on resources and never folds it into metadata', () => {
+  it('keeps memory on resources and never folds it into metadata (cloud)', () => {
     const payload = buildSessionCreatePayload({
       ...BASE,
       memoryStoreId: 'memstore_01',
@@ -123,6 +123,48 @@ describe('buildSessionCreatePayload — metadata', () => {
   })
 })
 
+describe('buildSessionCreatePayload — self-hosted routing', () => {
+  it('routes memory to metadata and never sends resources (self-hosted rejects resources)', () => {
+    const payload = buildSessionCreatePayload({
+      ...BASE,
+      environmentType: 'self_hosted',
+      memoryStoreId: 'memstore_01',
+      memoryAccess: 'read_only',
+      sessionParameters: { SOURCE_TYPE: 'git' },
+    })
+    expect(payload.resources).toBeUndefined()
+    expect(payload.metadata).toEqual({
+      SOURCE_TYPE: 'git',
+      memory_store_ids: 'memstore_01',
+      memory_access: 'read_only',
+    })
+  })
+
+  it('drops file attachments on self-hosted (not supported as resources)', () => {
+    const payload = buildSessionCreatePayload({
+      ...BASE,
+      environmentType: 'self_hosted',
+      files: [{ fileId: 'file_1' }],
+    })
+    expect(payload.resources).toBeUndefined()
+    expect(payload.metadata).toBeUndefined()
+  })
+
+  it('cloud (default) still attaches memory + files as resources', () => {
+    const payload = buildSessionCreatePayload({
+      ...BASE,
+      environmentType: 'cloud',
+      memoryStoreId: 'memstore_01',
+      files: [{ fileId: 'file_1' }],
+    })
+    expect(payload.resources).toEqual([
+      { type: 'memory_store', memory_store_id: 'memstore_01', access: 'read_write' },
+      { type: 'file', file_id: 'file_1' },
+    ])
+    expect(payload.metadata).toBeUndefined()
+  })
+})
+
 describe('listSessionEvents — ordering', () => {
   const originalFetch = global.fetch
   afterEach(() => {

apps/sim/lib/managed-agents/session-client.ts

@@ -51,6 +51,12 @@ export interface SessionAuth {
 export interface CreateSessionInput extends SessionAuth {
   agentId: string
   environmentId: string
+  /**
+   * Environment execution model. Self-hosted environments reject the
+   * `resources` array, so memory is routed via `metadata` and files are
+   * dropped for them. Defaults to cloud behavior when unset.
+   */
+  environmentType?: EnvironmentType
   /** Optional session title stored on the Anthropic session. */
   title?: string
   /** OAuth credential vaults the agent's MCP tools can reference. */
@@ -77,6 +83,9 @@ export interface SessionUsage {
   outputTokens?: number
 }
 
+/** Environment execution model per `GET /v1/environments/{id}` → `config.type`. */
+export type EnvironmentType = 'cloud' | 'self_hosted'
+
 /** Authoritative session status per `GET /v1/sessions/{id}`. */
 export type SessionStatus = 'idle' | 'running' | 'rescheduling' | 'terminated'
 
@@ -105,10 +114,14 @@ function managedAgentsHeaders(
 }
 
 /**
- * Builds the request body for `POST /v1/sessions`. Memory stores and files
- * attach via the `resources[]` array; user key/values go on `metadata`. This
- * shape is env-type agnostic — the same body works for cloud and self-hosted
- * environments per the docs.
+ * Builds the request body for `POST /v1/sessions`.
+ *
+ * Cloud environments attach memory stores and files via the `resources[]`
+ * array. Self-hosted environments REJECT `resources` (a documented 400 —
+ * "resources are not supported with self-hosted environments"), so there the
+ * memory store is surfaced to the worker via `metadata.memory_store_ids` /
+ * `metadata.memory_access` and files are dropped. Session parameters always go
+ * on `metadata` for both.
  */
 export function buildSessionCreatePayload(input: CreateSessionInput): Record<string, unknown> {
   const payload: Record<string, unknown> = {
@@ -118,29 +131,38 @@ export function buildSessionCreatePayload(input: CreateSessionInput): Record<str
   if (input.title) payload.title = input.title
   if (input.vaultIds && input.vaultIds.length > 0) payload.vault_ids = input.vaultIds
 
-  const resources: Array<Record<string, unknown>> = []
-  if (input.memoryStoreId) {
-    const memory: Record<string, unknown> = {
-      type: 'memory_store',
-      memory_store_id: input.memoryStoreId,
-      access: input.memoryAccess ?? 'read_write',
+  const metadata: Record<string, string> = { ...(input.sessionParameters ?? {}) }
+
+  if (input.environmentType === 'self_hosted') {
+    // No `resources` on self-hosted — route memory through metadata (the
+    // worker consumes these keys) and drop file attachments.
+    if (input.memoryStoreId) {
+      metadata.memory_store_ids = input.memoryStoreId
+      metadata.memory_access = input.memoryAccess ?? 'read_write'
     }
-    if (input.memoryInstructions) memory.instructions = input.memoryInstructions
-    resources.push(memory)
-  }
-  if (input.files && input.files.length > 0) {
-    for (const file of input.files) {
-      if (!file.fileId) continue
-      const entry: Record<string, unknown> = { type: 'file', file_id: file.fileId }
-      if (file.mountPath) entry.mount_path = file.mountPath
-      resources.push(entry)
+  } else {
+    const resources: Array<Record<string, unknown>> = []
+    if (input.memoryStoreId) {
+      const memory: Record<string, unknown> = {
+        type: 'memory_store',
+        memory_store_id: input.memoryStoreId,
+        access: input.memoryAccess ?? 'read_write',
+      }
+      if (input.memoryInstructions) memory.instructions = input.memoryInstructions
+      resources.push(memory)
+    }
+    if (input.files && input.files.length > 0) {
+      for (const file of input.files) {
+        if (!file.fileId) continue
+        const entry: Record<string, unknown> = { type: 'file', file_id: file.fileId }
+        if (file.mountPath) entry.mount_path = file.mountPath
+        resources.push(entry)
+      }
     }
+    if (resources.length > 0) payload.resources = resources
   }
-  if (resources.length > 0) payload.resources = resources
 
-  if (input.sessionParameters && Object.keys(input.sessionParameters).length > 0) {
-    payload.metadata = { ...input.sessionParameters }
-  }
+  if (Object.keys(metadata).length > 0) payload.metadata = metadata
   return payload
 }
 
@@ -344,6 +366,30 @@ export async function managedAgentsList<T>(
   })
 }
 
+/**
+ * GET /v1/environments/{id} — resolves the environment's execution model from
+ * `config.type`. Drives session-payload routing: self-hosted rejects
+ * `resources`. Returns `undefined` on any error so the caller can fall back to
+ * cloud behavior.
+ */
+export async function getEnvironmentType(
+  input: SessionAuth & { environmentId: string }
+): Promise<EnvironmentType | undefined> {
+  try {
+    const resp = await fetch(`${ANTHROPIC_API_BASE}/v1/environments/${input.environmentId}`, {
+      method: 'GET',
+      headers: managedAgentsHeaders(input.apiKey),
+      signal: input.signal,
+    })
+    if (!resp.ok) return undefined
+    const body = (await resp.json()) as { config?: { type?: unknown } }
+    const type = body.config?.type
+    return type === 'cloud' || type === 'self_hosted' ? type : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * GET /v1/sessions/{id} — retrieves the session resource. Returns the
  * authoritative `status` (used to decide completion when the event stream is