@hyperdrive.bot/paseo-server 0.3.3 → 0.3.5

package/dist/server/server/agent/provider-registry.js

@@ -111,7 +111,7 @@ function getProviderClientFactory(provider) {
     return factory;
 }
 function toRuntimeSettings(override) {
-    if (!override?.command && !override?.env && !override?.disallowedTools) {
+    if (!override?.command && !override?.env && !override?.disallowedTools && !override?.transport) {
         return undefined;
     }
     return {
@@ -123,7 +123,14 @@ function toRuntimeSettings(override) {
             : undefined,
         env: override.env,
         disallowedTools: override.disallowedTools,
-        transport: "sdk",
+        // Carry the configured transport through, and leave it undefined when the
+        // override does not set one. This field is the `override` side of
+        // mergeRuntimeSettings' `override?.transport ?? base?.transport ?? "auto"`,
+        // so hardcoding a value here silently wins over both the inherited base and
+        // the documented "auto" default: any provider that merely set `env` (every
+        // proxy-backed provider that extends claude) was pinned to "sdk" and could
+        // neither inherit a base opt-in nor honour its own configured transport.
+        transport: override.transport,
     };
 }
 function mergeEnv(baseEnv, overrideEnv) {

package/dist/server/server/config.js

@@ -81,7 +81,9 @@ function extractAgentProviderSettings(providerOverrides) {
     }
     const runtimeSettings = Object.entries(providerOverrides).flatMap(([providerId, provider]) => {
         const parsedProviderId = AgentProviderSchema.safeParse(providerId);
-        if (!parsedProviderId.success || (!provider.command && !provider.env)) {
+        // transport counts as a reason to keep the entry: an override that only sets
+        // transport (no command, no env) is the normal way to opt a provider into PTY.
+        if (!parsedProviderId.success || (!provider.command && !provider.env && !provider.transport)) {
             return [];
         }
         return [
@@ -95,6 +97,7 @@ function extractAgentProviderSettings(providerOverrides) {
                         }
                         : undefined,
                     env: provider.env,
+                    transport: provider.transport,
                 },
             ],
         ];

package/dist/server/server/persisted-config.d.ts

@@ -236,6 +236,11 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
             enabled: z.ZodOptional<z.ZodBoolean>;
             order: z.ZodOptional<z.ZodNumber>;
+            transport: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                sdk: "sdk";
+                pty: "pty";
+            }>>;
         }, z.core.$strip>>>>;
         metadataGeneration: z.ZodOptional<z.ZodObject<{
             providers: z.ZodOptional<z.ZodArray<z.ZodObject<{

package/dist/server/server/session.js

@@ -1635,6 +1635,20 @@ export class Session {
                 return this.handleFileUploadBeginRequest(msg);
             case "files.upload.complete.request":
                 return this.handleFileUploadCompleteRequest(msg);
+            case "files.upload.chunk": {
+                // Text transport for chunk bytes (base64 in a JSON message) instead of a binary
+                // FileChunk frame: binary WS frames are dropped by some proxies (the hyperdrive proxy
+                // path), which stalls the client's windowed sender with zero acks. Decode and feed the
+                // decoded bytes through the EXACT SAME queue as the binary path, so write ordering,
+                // backpressure, the per-chunk ack, and the over-cap abort are all identical. The daemon
+                // assigns its own chunkIndex in the ack (msg.payload.chunkIndex is informational only).
+                this.handleFileUploadFrame({
+                    opcode: FileTransferOpcode.FileChunk,
+                    requestId: msg.payload.requestId,
+                    payload: Buffer.from(msg.payload.data, "base64"),
+                });
+                return undefined;
+            }
             case "files.upload.error":
                 // Client already knows about its own abort — clean up without echoing an error back.
                 void this.abortFileUpload(msg.payload.requestId, null);