Always include schema TypeScript previews

Author: RhysSullivan

apps/cli/src/main.ts

@@ -1072,7 +1072,6 @@ const runCallHelp = (
               scopeId: scopeInfo.id,
               toolId: exactTool.id,
             },
-            query: { includeTypeScript: "true" },
           })
           .pipe(Effect.catchCause(() => Effect.succeed(undefined)))
       : undefined;

packages/core/api/src/handlers/tools.ts

@@ -28,13 +28,11 @@ export const ToolsHandlers = HttpApiBuilder.group(ExecutorApi, "tools", (handler
         }),
       ),
     )
-    .handle("schema", ({ params: path, query }) =>
+    .handle("schema", ({ params: path }) =>
       capture(
         Effect.gen(function* () {
           const executor = yield* ExecutorService;
-          const schema = yield* executor.tools.schema(path.toolId, {
-            includeTypeScript: query.includeTypeScript === "true",
-          });
+          const schema = yield* executor.tools.schema(path.toolId);
           if (schema === null) {
             return yield* new ToolNotFoundError({ toolId: path.toolId });
           }

packages/core/api/src/tools/api.ts

@@ -11,10 +11,6 @@ const PathParams = {
   toolId: ToolId,
 };
 
-const ToolSchemaQuery = Schema.Struct({
-  includeTypeScript: Schema.optional(Schema.Literal("true")),
-});
-
 // ---------------------------------------------------------------------------
 // Response schemas
 // ---------------------------------------------------------------------------
@@ -57,7 +53,6 @@ export const ToolsApi = HttpApiGroup.make("tools")
   .add(
     HttpApiEndpoint.get("schema", "/scopes/:scopeId/tools/:toolId/schema", {
       params: PathParams,
-      query: ToolSchemaQuery,
       success: ToolSchemaResponse,
       error: [InternalError, ToolNotFound],
     }),

packages/core/sdk/src/executor.test.ts

@@ -283,9 +283,7 @@ describe("createExecutor", () => {
 
       yield* executor.schemaProbe.registerSource();
 
-      const schema = yield* executor.tools.schema("schema-source.inspect", {
-        includeTypeScript: false,
-      });
+      const schema = yield* executor.tools.schema("schema-source.inspect");
 
       expect(schema?.inputSchema).toEqual({
         type: "object",
@@ -303,14 +301,9 @@ describe("createExecutor", () => {
         Pet: expect.any(Object),
       });
       expect(schema?.schemaDefinitions).not.toHaveProperty("Unused");
-      expect(schema?.inputTypeScript).toBeUndefined();
-      expect(schema?.outputTypeScript).toBeUndefined();
-      expect(schema?.typeScriptDefinitions).toBeUndefined();
-
-      const schemaWithTypes = yield* executor.tools.schema("schema-source.inspect");
-      expect(schemaWithTypes?.inputTypeScript).toContain("pet: Pet");
-      expect(schemaWithTypes?.outputTypeScript).toBe("Owner");
-      expect(schemaWithTypes?.typeScriptDefinitions).toEqual(
+      expect(schema?.inputTypeScript).toContain("pet: Pet");
+      expect(schema?.outputTypeScript).toBe("Owner");
+      expect(schema?.typeScriptDefinitions).toEqual(
         expect.objectContaining({
           Pet: expect.any(String),
           Owner: expect.any(String),

packages/core/sdk/src/executor.ts

@@ -121,7 +121,6 @@ import {
   type SourceDetectionResult,
   type Tool,
   type ToolListFilter,
-  type ToolSchemaOptions,
 } from "./types";
 import { buildToolTypeScriptPreview, type ToolTypeScriptPreview } from "./schema-types";
 import { collectReferencedDefinitions } from "./schema-refs";
@@ -183,11 +182,8 @@ export type Executor<TPlugins extends readonly AnyPlugin[] = readonly []> = {
     readonly list: (filter?: ToolListFilter) => Effect.Effect<readonly Tool[], StorageFailure>;
     /** Fetch a tool's schema view: JSON schemas with `$defs`
      *  attached from the core `definition` table, plus TypeScript
-     *  preview strings unless disabled. Returns `null` for unknown tool ids. */
-    readonly schema: (
-      toolId: string,
-      options?: ToolSchemaOptions,
-    ) => Effect.Effect<ToolSchema | null, StorageFailure>;
+     *  preview strings. Returns `null` for unknown tool ids. */
+    readonly schema: (toolId: string) => Effect.Effect<ToolSchema | null, StorageFailure>;
     /** Every `$defs` entry across every source, grouped by source id.
      *  Used for bulk schema export and downstream TypeScript rendering. */
     readonly definitions: () => Effect.Effect<
@@ -2984,7 +2980,6 @@ export const createExecutor = <const TPlugins extends readonly AnyPlugin[] = rea
       sourceId: string | undefined;
       rawInput: unknown;
       rawOutput: unknown;
-      includeTypeScript: boolean;
     }) =>
       Effect.gen(function* () {
         const defs: Record<string, unknown> = opts.sourceId
@@ -2999,25 +2994,23 @@ export const createExecutor = <const TPlugins extends readonly AnyPlugin[] = rea
           sourceDefsMap,
         );
         const schemaDefsMap = new Map<string, unknown>(Object.entries(schemaDefinitions));
-        const preview: ToolTypeScriptPreview = opts.includeTypeScript
-          ? yield* Effect.promise(() =>
-              buildToolTypeScriptPreview({
-                inputSchema: opts.rawInput,
-                outputSchema: opts.rawOutput,
-                defs: schemaDefsMap,
-              }),
-            ).pipe(
-              Effect.withSpan("schema.compile.preview", {
-                attributes: {
-                  "schema.kind": "tool.preview",
-                  "schema.has_input": opts.rawInput !== undefined,
-                  "schema.has_output": opts.rawOutput !== undefined,
-                  "schema.def_count": schemaDefsMap.size,
-                  "schema.source_def_count": sourceDefsMap.size,
-                },
-              }),
-            )
-          : {};
+        const preview: ToolTypeScriptPreview = yield* Effect.promise(() =>
+          buildToolTypeScriptPreview({
+            inputSchema: opts.rawInput,
+            outputSchema: opts.rawOutput,
+            defs: schemaDefsMap,
+          }),
+        ).pipe(
+          Effect.withSpan("schema.compile.preview", {
+            attributes: {
+              "schema.kind": "tool.preview",
+              "schema.has_input": opts.rawInput !== undefined,
+              "schema.has_output": opts.rawOutput !== undefined,
+              "schema.def_count": schemaDefsMap.size,
+              "schema.source_def_count": sourceDefsMap.size,
+            },
+          }),
+        );
 
         return ToolSchema.make({
           id: ToolId.make(opts.toolId),
@@ -3033,9 +3026,8 @@ export const createExecutor = <const TPlugins extends readonly AnyPlugin[] = rea
         });
       });
 
-    const toolSchema = (toolId: string, options?: ToolSchemaOptions) =>
+    const toolSchema = (toolId: string) =>
       Effect.gen(function* () {
-        const includeTypeScript = options?.includeTypeScript ?? true;
         // Static pool first — static tools have no source in the DB so
         // no `$defs` attach; just wrap the declared schemas.
         const staticEntry = staticTools.get(toolId);
@@ -3052,7 +3044,6 @@ export const createExecutor = <const TPlugins extends readonly AnyPlugin[] = rea
             sourceId: undefined,
             rawInput: toToolJsonSchema(staticEntry.tool.inputSchema),
             rawOutput: toToolJsonSchema(staticEntry.tool.outputSchema, "output"),
-            includeTypeScript,
           });
         }
         // Innermost-wins lookup across every visible scope.
@@ -3075,7 +3066,6 @@ export const createExecutor = <const TPlugins extends readonly AnyPlugin[] = rea
           sourceId: row.source_id,
           rawInput: decodeJsonColumn(row.input_schema),
           rawOutput: decodeJsonColumn(row.output_schema),
-          includeTypeScript,
         });
       }).pipe(
         Effect.withSpan("executor.tool.schema", {

packages/core/sdk/src/types.ts

@@ -84,11 +84,6 @@ export const ToolSchema = Schema.Struct({
 });
 export type ToolSchema = typeof ToolSchema.Type;
 
-export interface ToolSchemaOptions {
-  /** Include TypeScript preview strings. Defaults to true for SDK callers. */
-  readonly includeTypeScript?: boolean;
-}
-
 // ---------------------------------------------------------------------------
 // Source detection — optional capability on `PluginSpec.detect`. When a
 // user pastes a URL in the onboarding UI, `executor.sources.detect(url)`

packages/react/src/api/atoms.tsx

@@ -42,7 +42,6 @@ export const sourceToolsAtom = (sourceId: string, scopeId: ScopeId) =>
 export const toolSchemaAtom = (scopeId: ScopeId, toolId: ToolId) =>
   ExecutorApiClient.query("tools", "schema", {
     params: { scopeId, toolId },
-    query: { includeTypeScript: "true" },
     timeToLive: "1 minute",
     reactivityKeys: [ReactivityKey.tools],
   });