managed-deepagents 0.9.0-dev.1 → 0.9.0-dev.3

package/dist/runtime/index.d.ts

@@ -1,6 +1,7 @@
-import type { DeepAgentDefinition } from "../types.js";
+import type { AgentEntry } from "../agent-entry.js";
 import type { ManagedAgentOptions, ManagedRunConfig, ManagedServerRuntime } from "./types.js";
 export type { ManagedAgentOptions, ManagedRunConfig, ManagedServerRuntime, } from "./types.js";
+export { assertStaticAgentDefinition } from "./static-entry.js";
 export { createEvalTrialFilesystemBackend } from "./eval-filesystem.js";
 export { buildManagedAuth } from "./auth.js";
 export { buildManagedHttpApp } from "./identity-http.js";
@@ -26,116 +27,7 @@ export declare const MANAGED_DEEP_AGENT_INSTRUCTIONS: string;
  * scratch fallback, and managed memory/skills. It is consumed only by the
  * generated entry module; agent authors never call it.
  */
-export declare function compileManagedAgent(definition: DeepAgentDefinition, config?: ManagedRunConfig, options?: ManagedAgentOptions, runtime?: ManagedServerRuntime): Promise<import("langchain").ReactAgent<import("deepagents").DeepAgentTypeConfig<import("langchain").ResponseFormatUndefined, undefined, import("@langchain/core/utils/types").InteropZodObject, readonly [import("langchain").AgentMiddleware<import("@langchain/langgraph").StateSchema<{
-    files: import("@langchain/langgraph").ReducedValue<{
-        [x: string]: import("deepagents").FileData;
-    } | undefined, {
-        [x: string]: import("deepagents").FileData | null;
-    } | undefined>;
-}>, undefined, unknown, (import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    path: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
-}, import("zod/v4/core").$strip>, {
-    path: string;
-}, {
-    path?: string | undefined;
-}, string | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "ls"> | import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    pattern: import("zod").ZodString;
-    path: import("zod").ZodOptional<import("zod").ZodString>;
-}, import("zod/v4/core").$strip>, {
-    pattern: string;
-    path?: string | undefined;
-}, {
-    pattern: string;
-    path?: string | undefined;
-}, string | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "glob"> | import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    pattern: import("zod").ZodString;
-    path: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
-    glob: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>>;
-    max_count: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>>;
-    output_mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
-        content: "content";
-        count: "count";
-        files_with_matches: "files_with_matches";
-    }>>>;
-}, import("zod/v4/core").$strip>, {
-    pattern: string;
-    path: string;
-    glob: string | null;
-    max_count: number | null;
-    output_mode: "content" | "count" | "files_with_matches";
-}, {
-    pattern: string;
-    path?: string | undefined;
-    glob?: string | null | undefined;
-    max_count?: unknown;
-    output_mode?: "content" | "count" | "files_with_matches" | undefined;
-}, string | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "grep"> | import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    command: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, {
-    command: string;
-}, {
-    command: string;
-}, string, unknown, "execute"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
-    file_path: import("zod").ZodString;
-    offset: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
-    limit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
-}, import("zod/v4/core").$strip>, unknown>, {
-    file_path: string;
-    offset: number;
-    limit: number;
-}, unknown, {
-    type: string;
-    text: string;
-}[] | {
-    type: string;
-    mimeType: string;
-    data: string;
-}[] | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "read_file"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
-    file_path: import("zod").ZodString;
-    content: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, unknown>, {
-    file_path: string;
-    content: string;
-}, unknown, string | import("@langchain/langgraph").Command<unknown, {
-    files: Record<string, import("deepagents").FileData>;
-    messages: import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>[];
-}, string> | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "write_file"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
-    file_path: import("zod").ZodString;
-    old_string: import("zod").ZodString;
-    new_string: import("zod").ZodString;
-    replace_all: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-}, import("zod/v4/core").$strip>, unknown>, {
-    file_path: string;
-    old_string: string;
-    new_string: string;
-    replace_all: boolean;
-}, unknown, string | import("@langchain/langgraph").Command<unknown, {
-    files: Record<string, import("deepagents").FileData>;
-    messages: import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>[];
-}, string> | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "edit_file"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
-    file_path: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, unknown>, {
-    file_path: string;
-}, unknown, import("@langchain/langgraph").Command<unknown, {
-    files: Record<string, null>;
-    messages: import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>[];
-}, string> | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "delete">)[], readonly []>, import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly [import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    description: import("zod").ZodString;
-    subagent_type: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, {
-    description: string;
-    subagent_type: string;
-}, {
-    description: string;
-    subagent_type: string;
-}, string | import("@langchain/langgraph").Command<unknown, Record<string, unknown>, string>, unknown, "task">], readonly []>, import("langchain").AgentMiddleware<import("zod").ZodObject<{
-    _summarizationSessionId: import("zod").ZodOptional<import("zod").ZodString>;
-    _summarizationEvent: import("zod").ZodOptional<import("zod").ZodObject<{
-        cutoffIndex: import("zod").ZodNumber;
-        summaryMessage: import("zod").ZodCustom<import("langchain").HumanMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, import("langchain").HumanMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>>;
-        filePath: import("zod").ZodNullable<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>>;
-}, import("zod/v4/core").$strip>, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>, import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>], readonly [], readonly [], readonly []>>>;
+export declare function compileManagedAgent(entry: AgentEntry, config?: ManagedRunConfig, options?: ManagedAgentOptions, runtime?: ManagedServerRuntime): Promise<any>;
 export interface ManagedEvalOptions extends Omit<ManagedAgentOptions, "contextRepo" | "sandbox" | "memory"> {
     modelOverride?: string;
 }
@@ -156,114 +48,5 @@ export interface ManagedEvalOptions extends Omit<ManagedAgentOptions, "contextRe
  * The model override is applied to a copied definition so normal dev/deploy
  * behavior remains unchanged.
  */
-export declare function compileManagedAgentForEval(definition: DeepAgentDefinition, config?: ManagedRunConfig, options?: ManagedEvalOptions): Promise<import("langchain").ReactAgent<import("deepagents").DeepAgentTypeConfig<import("langchain").ResponseFormatUndefined, undefined, import("@langchain/core/utils/types").InteropZodObject, readonly [import("langchain").AgentMiddleware<import("@langchain/langgraph").StateSchema<{
-    files: import("@langchain/langgraph").ReducedValue<{
-        [x: string]: import("deepagents").FileData;
-    } | undefined, {
-        [x: string]: import("deepagents").FileData | null;
-    } | undefined>;
-}>, undefined, unknown, (import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    path: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
-}, import("zod/v4/core").$strip>, {
-    path: string;
-}, {
-    path?: string | undefined;
-}, string | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "ls"> | import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    pattern: import("zod").ZodString;
-    path: import("zod").ZodOptional<import("zod").ZodString>;
-}, import("zod/v4/core").$strip>, {
-    pattern: string;
-    path?: string | undefined;
-}, {
-    pattern: string;
-    path?: string | undefined;
-}, string | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "glob"> | import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    pattern: import("zod").ZodString;
-    path: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
-    glob: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodString>>>;
-    max_count: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>>;
-    output_mode: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEnum<{
-        content: "content";
-        count: "count";
-        files_with_matches: "files_with_matches";
-    }>>>;
-}, import("zod/v4/core").$strip>, {
-    pattern: string;
-    path: string;
-    glob: string | null;
-    max_count: number | null;
-    output_mode: "content" | "count" | "files_with_matches";
-}, {
-    pattern: string;
-    path?: string | undefined;
-    glob?: string | null | undefined;
-    max_count?: unknown;
-    output_mode?: "content" | "count" | "files_with_matches" | undefined;
-}, string | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "grep"> | import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    command: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, {
-    command: string;
-}, {
-    command: string;
-}, string, unknown, "execute"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
-    file_path: import("zod").ZodString;
-    offset: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
-    limit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
-}, import("zod/v4/core").$strip>, unknown>, {
-    file_path: string;
-    offset: number;
-    limit: number;
-}, unknown, {
-    type: string;
-    text: string;
-}[] | {
-    type: string;
-    mimeType: string;
-    data: string;
-}[] | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "read_file"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
-    file_path: import("zod").ZodString;
-    content: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, unknown>, {
-    file_path: string;
-    content: string;
-}, unknown, string | import("@langchain/langgraph").Command<unknown, {
-    files: Record<string, import("deepagents").FileData>;
-    messages: import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>[];
-}, string> | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "write_file"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
-    file_path: import("zod").ZodString;
-    old_string: import("zod").ZodString;
-    new_string: import("zod").ZodString;
-    replace_all: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-}, import("zod/v4/core").$strip>, unknown>, {
-    file_path: string;
-    old_string: string;
-    new_string: string;
-    replace_all: boolean;
-}, unknown, string | import("@langchain/langgraph").Command<unknown, {
-    files: Record<string, import("deepagents").FileData>;
-    messages: import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>[];
-}, string> | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "edit_file"> | import("langchain").DynamicStructuredTool<import("zod").ZodPreprocess<import("zod").ZodObject<{
-    file_path: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, unknown>, {
-    file_path: string;
-}, unknown, import("@langchain/langgraph").Command<unknown, {
-    files: Record<string, null>;
-    messages: import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>[];
-}, string> | import("langchain").ToolMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, unknown, "delete">)[], readonly []>, import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly [import("langchain").DynamicStructuredTool<import("zod").ZodObject<{
-    description: import("zod").ZodString;
-    subagent_type: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, {
-    description: string;
-    subagent_type: string;
-}, {
-    description: string;
-    subagent_type: string;
-}, string | import("@langchain/langgraph").Command<unknown, Record<string, unknown>, string>, unknown, "task">], readonly []>, import("langchain").AgentMiddleware<import("zod").ZodObject<{
-    _summarizationSessionId: import("zod").ZodOptional<import("zod").ZodString>;
-    _summarizationEvent: import("zod").ZodOptional<import("zod").ZodObject<{
-        cutoffIndex: import("zod").ZodNumber;
-        summaryMessage: import("zod").ZodCustom<import("langchain").HumanMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>, import("langchain").HumanMessage<import("@langchain/core/messages").MessageStructure<import("@langchain/core/messages").MessageToolSet>>>;
-        filePath: import("zod").ZodNullable<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>>;
-}, import("zod/v4/core").$strip>, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>, import("langchain").AgentMiddleware<undefined, undefined, unknown, readonly (import("@langchain/core/tools").ServerTool | import("@langchain/core/tools").ClientTool)[], readonly []>], readonly [], readonly [], readonly []>>>;
+export declare function compileManagedAgentForEval(entry: AgentEntry, config?: ManagedRunConfig, options?: ManagedEvalOptions): Promise<any>;
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAyCvD,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAIpB,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAIzD,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,WAAW,EACX,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,SAAS,EACT,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,yBAAyB,EACzB,aAAa,EACb,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,WAAW,GACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,aAAa,EACb,eAAe,EACf,SAAS,EACT,wBAAwB,GACzB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,OAAO,EACP,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAG9C,eAAO,MAAM,+BAA+B,QAGnB,CAAC;AAE1B;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,mBAAmB,EAC/B,MAAM,CAAC,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2YAkB/B;AAuUD,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAC9C,mBAAmB,EACnB,aAAa,GAAG,SAAS,GAAG,QAAQ,CACrC;IACC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,mBAAmB,EAC/B,MAAM,CAAC,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2YAuB7B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAsDpD,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAUpB,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,gCAAgC,EAAE,MAAM,sBAAsB,CAAC;AAExE,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAIzD,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,WAAW,EACX,kBAAkB,EAClB,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,SAAS,EACT,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,yBAAyB,EACzB,aAAa,EACb,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,WAAW,GACZ,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,aAAa,EACb,eAAe,EACf,SAAS,EACT,wBAAwB,GACzB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,OAAO,EACP,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAG9C,eAAO,MAAM,+BAA+B,QAGnB,CAAC;AAO1B;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,UAAU,EACjB,MAAM,CAAC,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,oBAAoB,gBA4C/B;AA8cD,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAC9C,mBAAmB,EACnB,aAAa,GAAG,SAAS,GAAG,QAAQ,CACrC;IACC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,UAAU,EACjB,MAAM,CAAC,EAAE,gBAAgB,EACzB,OAAO,CAAC,EAAE,kBAAkB,gBAsC7B"}

package/dist/runtime/index.js

@@ -1,6 +1,9 @@
 import { createSlackFileTransferMiddleware } from "../channels/slack/files-middleware.js";
 import { ContextHubBackend, FilesystemBackend, createDeepAgent, } from "deepagents";
+import { snapshotMemorySelection, snapshotMcpSelection, snapshotSandboxSelection, } from "../managed-composition.js";
 import { LazyManagedSandboxBackend } from "./backend.js";
+import { sandboxSelectionFingerprint } from "./sandbox-manager.js";
+import { resolveAgentDefinition } from "./agent-entry.js";
 import { loadConnectorTools } from "./connector.js";
 import { createScheduleDeliveryMiddleware } from "../channels/schedule-delivery.js";
 import { createChannelResponseFormatMiddleware } from "../channels/response-format.js";
@@ -11,14 +14,17 @@ import { wrapMiddlewareWithManagedRuntime, } from "./managed-middleware.js";
 import { wrapToolsWithManagedRuntime, } from "./managed-tools.js";
 import { createMemoryInstructionsMiddleware, hasAgentMemoryLayer, userMemoryLayer, } from "../memory/index.js";
 import { resolveAgentMemoryAccess, resolveUserMemoryAccess, } from "./memory/policy.js";
-import { resolveChannelProvider } from "../channels/binding.js";
+import { resolveChannelProvider, resolveRuntimeChannel, } from "../channels/binding.js";
 import { detectRunIdentity } from "../telemetry/metadata.js";
 import { RunTelemetryListener } from "../telemetry/run-listener.js";
 import { startRun } from "../telemetry/run.js";
-import { asText, downloadContextFile, managedContextBackend, managedContextPermissions, UserMemoryBackend, } from "./memory/index.js";
+import { asText, downloadContextFile, managedContextBackend, managedContextPermissions, managedSelectedSkillsBackend, UserMemoryBackend, } from "./memory/index.js";
+import { resolveSelectedSkills } from "./selected-skills.js";
 import { createEvalTrialFilesystemBackend } from "./eval-filesystem.js";
-import { selectContextSchema, isRunExecution } from "./run-input.js";
+import { adaptChannelExecution, executionContext, isChannelExecution, isRunExecution, } from "./run-input.js";
+import { managedChannelContextSchema } from "../run-context.js";
 import { registerChannelMessaging } from "../channels/messaging-registry.js";
+export { assertStaticAgentDefinition } from "./static-entry.js";
 export { createEvalTrialFilesystemBackend } from "./eval-filesystem.js";
 export { buildManagedAuth } from "./auth.js";
 export { buildManagedHttpApp } from "./identity-http.js";
@@ -47,34 +53,113 @@ export const MANAGED_DEEP_AGENT_INSTRUCTIONS = "<managed_deep_agent>\n" +
  * scratch fallback, and managed memory/skills. It is consumed only by the
  * generated entry module; agent authors never call it.
  */
-export async function compileManagedAgent(definition, config, options, runtime) {
-    registerChannelMessaging(options?.channels ?? []);
+export async function compileManagedAgent(entry, config, options, runtime) {
     const isRun = runtime
         ? runtime.executionRuntime !== null
         : isRunExecution(config);
     const runConfig = runtime?.executionRuntime
         ? { ...config, context: runtime.executionRuntime.context }
         : config;
-    const contextSchema = isRun
-        ? selectContextSchema(runConfig, definition.config.contextSchema)
-        : definition.config.contextSchema;
-    return compileManagedAgentGraph({ ...definition, config: { ...definition.config, contextSchema } }, runConfig, options, isRun);
+    registerChannelMessaging(options?.channels ?? []);
+    const nativeRuntime = runtime ?? internalServerRuntime(config?.context, isRun);
+    const { binding } = isRun
+        ? executionContext(runConfig)
+        : { binding: undefined };
+    const extras = {
+        channel: binding
+            ? resolveRuntimeChannel({ channel: binding }, runConfig?.configurable)
+            : undefined,
+        backend: undefined,
+    };
+    const factoryRuntime = nativeRuntime.executionRuntime
+        ? {
+            ...nativeRuntime,
+            ...extras,
+            executionRuntime: {
+                ...nativeRuntime.executionRuntime,
+                context: isRun && isChannelExecution(runConfig)
+                    ? undefined
+                    : nativeRuntime.executionRuntime.context,
+            },
+        }
+        : { ...nativeRuntime, ...extras };
+    const factoryEntry = typeof entry === "function";
+    const skipFactoryInspectionTools = factoryEntry && !isRun;
+    const definition = await resolveAgentDefinition(entry, factoryRuntime);
+    return compileResolvedManagedAgent(definition, runConfig, options, isRun, skipFactoryInspectionTools, factoryEntry);
+}
+/** Internal/eval calls do not have an Agent Server runtime. */
+function internalServerRuntime(context, isRun) {
+    return isRun
+        ? {
+            accessContext: "threads.create_run",
+            executionRuntime: {
+                context: (context ?? {}),
+            },
+        }
+        : { accessContext: "assistants.read", executionRuntime: null };
+}
+async function compileResolvedManagedAgent(definition, config, options, isRun, skipFactoryInspectionTools, factoryEntry = false) {
+    const connectors = selectRunConnectors(definition.config, options?.connectors);
+    const sandbox = options?.trialRootDir
+        ? undefined
+        : selectRunSandbox(definition.config, options?.sandbox);
+    const sandboxFingerprint = factoryEntry && sandbox && Object.hasOwn(definition.config, "sandbox")
+        ? sandboxSelectionFingerprint(sandbox)
+        : undefined;
+    const runOptions = Object.hasOwn(definition.config, "mcp") ||
+        Object.hasOwn(definition.config, "sandbox")
+        ? {
+            ...options,
+            connectors,
+            sandbox,
+            sandboxSelectionFingerprint: sandboxFingerprint,
+        }
+        : options;
+    registerChannelMessaging(options?.channels ?? []);
+    return adaptChannelExecution(await compileManagedAgentGraph(definition, config, runOptions, isRun, skipFactoryInspectionTools));
+}
+/** Replace or disable the discovered sandbox for this run. */
+function selectRunSandbox(config, discovered) {
+    if (!Object.hasOwn(config, "sandbox") || config.sandbox === undefined) {
+        return discovered;
+    }
+    return snapshotSandboxSelection(config.sandbox) ?? undefined;
 }
-async function compileManagedAgentGraph(definition, config, options, isRun = false) {
-    const { contextRoot, contextRepo, systemPrompt, hasSkills = false, sandbox, connectors, 
+/** Replace discovered MCP definitions while preserving every other connector. */
+function selectRunConnectors(config, discovered) {
+    if (!Object.hasOwn(config, "mcp") || config.mcp === undefined) {
+        return discovered;
+    }
+    const selected = config.mcp === null ? [] : snapshotMcpSelection(config.mcp);
+    return [
+        ...(discovered ?? []).filter((connector) => connector.kind !== "mcp_servers"),
+        ...selected,
+    ];
+}
+async function compileManagedAgentGraph(definition, config, options, isRun = false, skipFactoryInspectionTools = false) {
+    const { contextRoot, contextRepo, systemPrompt, hasSkills = false, sandbox, sandboxSelectionFingerprint, connectors, 
     // Resolution + thread/store scoping run in the generated custom-auth handler
     // (`buildManagedAuth`). When identity is declared, the seam also surfaces
     // `runtime.serverInfo.principal` to authored + connector tools (below).
     identity, 
-    // The root `memory.{ts,py}` declaration. Absent → no durable memory: the
-    // layers a run mounts come from here and nowhere else.
-    memory, trialRootDir, reportTelemetry = true, } = options ?? {};
+    // The autodiscovered root memory declaration. An explicit dynamic
+    // selection below replaces it for this run.
+    memory: discoveredMemory, trialRootDir, reportTelemetry = true, } = options ?? {};
     const startedMonotonicMs = performance.now();
-    const { metadata, ...agentConfig } = definition.config;
+    const { metadata, instructions: authoredInstructions, memory: authoredMemory, skills: skillSelection, ...agentConfig } = definition.config;
+    delete agentConfig.mcp;
+    delete agentConfig.sandbox;
+    const memorySelectedByDynamicResolver = Object.hasOwn(definition.config, "memory") && authoredMemory !== undefined;
+    const memory = memorySelectedByDynamicResolver
+        ? authoredMemory === null
+            ? undefined
+            : snapshotMemorySelection(authoredMemory)
+        : discoveredMemory;
     /** Layers mounted for this run, also used to state their objective policy. */
     let mountedMemory = [];
     /** Layers the project declared, whether or not this run was allowed them. */
-    let requestedMemory = [];
+    const declaredMemory = memory?.config.scope ?? [];
     let userDeniedReason = null;
     let loadAgentMemory;
     let loadUserMemory;
@@ -85,15 +170,16 @@ async function compileManagedAgentGraph(definition, config, options, isRun = fal
      * backend resolution below.
      *
      * Each connector's `tools` hook contributes tools appended to the authored
-     * tools. The author never imports the MCP client or calls `getTools()` — MDA
-     * owns the connector lifecycle.
+     * tools. The author never imports the MCP client or calls `listTools()` —
+     * MDA owns the connector lifecycle.
      */
-    const connectorToolsPromise = connectors && connectors.length > 0
+    const connectorToolsPromise = !skipFactoryInspectionTools && connectors && connectors.length > 0
         ? loadConnectorTools(connectors)
         : undefined;
     const sandboxBackend = sandbox
         ? LazyManagedSandboxBackend.create({
             sandbox,
+            sandboxSelectionFingerprint,
             runConfig: config,
             connectors,
             identity,
@@ -102,27 +188,36 @@ async function compileManagedAgentGraph(definition, config, options, isRun = fal
     const backendFactory = sandboxBackend
         ? (runtime) => sandboxBackend.bindRuntime(runtime)
         : undefined;
-    const contextBackend = await resolveContextBackend(contextRepo, contextRoot);
+    const contextBackend = skipFactoryInspectionTools
+        ? undefined
+        : await resolveContextBackend(contextRepo, contextRoot);
+    const selectedSkills = skillSelection === undefined || skipFactoryInspectionTools
+        ? undefined
+        : await resolveSelectedSkills(skillSelection ?? [], {
+            ...(trialRootDir
+                ? { localRoot: trialRootDir }
+                : contextBackend
+                    ? { contextBackend: contextBackend.backend }
+                    : {}),
+        });
     if (contextBackend) {
-        const hubPrompt = await readInstructions(contextBackend.backend);
-        if (hubPrompt !== undefined) {
-            params.systemPrompt = hubPrompt;
-        }
         // Memory is opt-in: only the root `memory` declaration enables a layer, so a
         // project that declares nothing mounts nothing regardless of identity.
-        const declaredLayers = memory?.config.scope ?? [];
-        requestedMemory = declaredLayers;
-        const agentLayer = declaredLayers.find((layer) => layer.type === "agent");
-        const userLayer = userMemoryLayer(declaredLayers);
-        const allowAgent = await resolveAgentMemoryAccess(agentLayer, config, agentConfig.contextSchema, isRun);
+        const agentLayer = declaredMemory.find((layer) => layer.type === "agent");
+        const userLayer = userMemoryLayer(declaredMemory);
+        const allowAgent = await resolveAgentMemoryAccess(agentLayer, config, isChannelExecution(config)
+            ? managedChannelContextSchema
+            : agentConfig.contextSchema, isRun);
         const userAccess = !userLayer
             ? { deniedReason: null }
             : isRun
-                ? await resolveUserMemoryAccess(userLayer, config, agentConfig.contextSchema)
+                ? await resolveUserMemoryAccess(userLayer, config, isChannelExecution(config)
+                    ? managedChannelContextSchema
+                    : agentConfig.contextSchema, memorySelectedByDynamicResolver)
                 : { deniedReason: "no_context" };
         const allowedUserId = userAccess.userId;
         userDeniedReason = userAccess.deniedReason;
-        const memoryLayers = declaredLayers.filter((layer) => layer.type === "agent" ? allowAgent : allowedUserId !== undefined);
+        const memoryLayers = declaredMemory.filter((layer) => layer.type === "agent" ? allowAgent : allowedUserId !== undefined);
         mountedMemory = memoryLayers;
         const userMemoryBackend = allowedUserId !== undefined
             ? new UserMemoryBackend({
@@ -137,7 +232,7 @@ async function compileManagedAgentGraph(definition, config, options, isRun = fal
         if (userMemoryBackend) {
             loadUserMemory = () => downloadContextFile(userMemoryBackend, "/AGENTS.md");
         }
-        params.backend = managedContextBackend(contextBackend.backend, sandboxBackend, hasAgentMemoryLayer(memoryLayers), userMemoryBackend);
+        params.backend = managedContextBackend(contextBackend.backend, sandboxBackend, hasAgentMemoryLayer(memoryLayers), userMemoryBackend, selectedSkills?.backend);
         // Sandbox + FilesystemPermission cannot coexist at execute() time: deepagents
         // adapts CompositeBackend and drops routePrefixes, so any permission rule
         // disables shell. Rely on read-only Context Hub mounts instead.
@@ -149,28 +244,43 @@ async function compileManagedAgentGraph(definition, config, options, isRun = fal
         }
     }
     else {
-        // Eval entries embed instructions directly; local/deploy prefer Context Hub.
-        if (systemPrompt !== undefined) {
-            params.systemPrompt = systemPrompt;
-        }
         if (sandboxBackend) {
             params.backend = sandboxBackend;
         }
         else if (trialRootDir) {
             // Harbor trial disk root — not via definition.config (authoring forbids backend).
-            params.backend = createEvalTrialFilesystemBackend(trialRootDir);
+            params.backend = createEvalTrialFilesystemBackend(trialRootDir, {
+                hideSkills: selectedSkills !== undefined,
+            });
+        }
+        if (selectedSkills) {
+            params.backend = managedSelectedSkillsBackend(params.backend, selectedSkills.backend);
+            params.permissions = sandboxBackend
+                ? []
+                : managedContextPermissions(params.permissions);
         }
     }
-    // Include platform context even when the project has no instructions.md.
-    const instructions = params.systemPrompt;
-    params.systemPrompt = instructions
-        ? `${MANAGED_DEEP_AGENT_INSTRUCTIONS}\n\n${instructions}`
+    // Explicit dynamic instructions replace the authored file, including `""`.
+    // Omission retains the discovered prompt, with eval's embedded prompt as a
+    // fallback. The platform boundary is always first and cannot be replaced.
+    let selectedInstructions = authoredInstructions;
+    if (selectedInstructions === undefined && contextBackend) {
+        selectedInstructions = await readInstructions(contextBackend.backend);
+    }
+    if (selectedInstructions === undefined) {
+        selectedInstructions = systemPrompt;
+    }
+    params.systemPrompt = selectedInstructions
+        ? `${MANAGED_DEEP_AGENT_INSTRUCTIONS}\n\n${selectedInstructions}`
         : MANAGED_DEEP_AGENT_INSTRUCTIONS;
     // Mounted the same way in every mode, but resolved against different roots:
     // local/deploy route `/skills/` to the Context Hub mock or repo, while an eval
     // trial reads the project's own `skills/` tree, which the Harbor adapter copies
     // into the trial workspace the backend is rooted at.
-    if (hasSkills) {
+    const effectiveHasSkills = skipFactoryInspectionTools && skillSelection !== undefined
+        ? (skillSelection?.length ?? 0) > 0
+        : (selectedSkills?.hasSkills ?? hasSkills);
+    if (effectiveHasSkills) {
         params.skills = [MANAGED_SKILLS_PATH];
     }
     // Add the managed fields to authored tools. Only authored tools receive
@@ -203,6 +313,7 @@ async function compileManagedAgentGraph(definition, config, options, isRun = fal
     if (mountedMemory.length > 0) {
         params.memory = mountedMemory.map((layer) => `/memories/${layer.type}/AGENTS.md`);
     }
+    // Inspection needs the credential gate, but must not load credentials.
     const credentialGate = createCredentialGateMiddleware([
         ...mcpCredentialConsumers(connectors),
         ...sandboxCredentialConsumers(sandbox),
@@ -236,7 +347,7 @@ async function compileManagedAgentGraph(definition, config, options, isRun = fal
             channel: detectRunChannel(config),
             sandboxDeclared: sandbox !== undefined,
             identityDeclared: identity !== undefined,
-            skillsDeclared: hasSkills,
+            skillsDeclared: effectiveHasSkills,
             backendKind: sandboxBackend
                 ? "sandbox"
                 : trialRootDir
@@ -248,7 +359,7 @@ async function compileManagedAgentGraph(definition, config, options, isRun = fal
                     ? "local"
                     : "none",
             memory: {
-                layers_declared: requestedMemory.map((layer) => layer.type),
+                layers_declared: declaredMemory.map((layer) => layer.type),
                 layers_mounted: mountedMemory.map((layer) => layer.type),
                 user_denied_reason: userDeniedReason,
             },
@@ -320,7 +431,12 @@ function wrapDeclarativeSubagents(subagents, backendFactory) {
  * The model override is applied to a copied definition so normal dev/deploy
  * behavior remains unchanged.
  */
-export async function compileManagedAgentForEval(definition, config, options) {
+export async function compileManagedAgentForEval(entry, config, options) {
+    // Harbor calls this helper only to execute a scored trial. Missing context
+    // means the run has empty authored context; it is not graph inspection.
+    const isRun = true;
+    const skipFactoryInspectionTools = false;
+    const definition = await resolveAgentDefinition(entry, internalServerRuntime(config?.context, true));
     const { modelOverride, ...managedOptions } = options ?? {};
     const configuredModel = configurableModel(config);
     const evalDefinition = {
@@ -332,7 +448,7 @@ export async function compileManagedAgentForEval(definition, config, options) {
                 : {}),
         },
     };
-    return compileManagedAgent(evalDefinition, config, {
+    return compileResolvedManagedAgent(evalDefinition, config, {
         ...managedOptions,
         // Eval trials never mount durable memory. The generated eval entry does not
         // pass a declaration and the option is omitted from `ManagedEvalOptions`;
@@ -341,7 +457,7 @@ export async function compileManagedAgentForEval(definition, config, options) {
         // Prefer runner-provided cwd; default matches the adapter's `/app` staging.
         trialRootDir: evalAppDir(config),
         reportTelemetry: false,
-    });
+    }, isRun, skipFactoryInspectionTools, typeof entry === "function");
 }
 function configurableModel(config) {
     const value = config?.configurable?.model;