The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Preview	Comments	Updated (UTC)
rivetkit-serverless	Ready	Preview	Comment	Nov 13, 2025 2:49am

3 Skipped Deployments

Project	Deployment	Preview	Comments	Updated (UTC)
rivet-cloud	Ignored			Nov 13, 2025 2:49am
rivet-inspector	Ignored	Preview		Nov 13, 2025 2:49am
rivet-site	Ignored	Preview		Nov 13, 2025 2:49am

• fix(rivetkit): remove incorrect getEndpoint call in metadata handler #3433 : 2 dependent PRs (#3438 , #3451 )
• feat(rivetkit): add json protocol support #3432
• chore(rivetkit): add required zod validation for json encoding #3431
• chore(rivetkit): add listing actors by only name to manager api #3430
• refactor(rivetkit): extract WebSocket protocol parsing to shared utility #3429
• refactor(rivetkit): restructure connection lifecycle contexts #3428
• chore(rivetkit): add WebSocketContext and RequestContext #3427
• chore(rivetkit): add conn type #3426 👈 (View in Graphite)
• chore(rivetkit): add connection for raw http #3425
• chore(rivetkit): rename onFetch to onRequest #3424
• refactor(rivetkit): add state manager for conn with symbol-based access #3423
• fix(rivetkit): use loggerWithoutContext for websocket error when actor undefined #3412
• feat(rivetkit): add GET /actors/names #3411
• feat(api-public): expose actor kv api #3410
• chore(rivetkit): auto-generate inspector token for engine driver #3409
• chore(rivetkit): close websockets on out of sequence messages #3404
• fix(rivetkit): properly apply clientEndpoint from metadata lookup #3402
• fix(rivetkit): properly handle msgIndex for hibernatable websocket reconnection #3401
• chore(rivetkit): rename onstart/onstop to onwake/onsleep #3422
• chore(rivetkit): split ActorInstance logic in to multiple classes #3421
• chore(rivetkit): move conns to separate persisted kv keys #3420
• chore(rivetkit): remove deprecated conn tokens & sse support #3419
• main

How to use the Graphite Merge Queue

Add the label merge-queue to this PR to add it to the merge queue.

You must have a Graphite account in order to use the merge queue. Sign up using this link.

This stack of pull requests is managed by Graphite. Learn more about stacking.

PR Review: Add Connection Type Field

Summary

This PR adds a type field to the ConnDriver interface for debugging purposes and renames the raw HTTP driver to raw-request for better clarity. The changes are well-structured and improve code maintainability.

Positive Aspects ✅

1. Improved Documentation: The new JSDoc comments on the ConnDriver interface fields (type, requestId, requestIdBuf, hibernatable) significantly improve code readability and understanding.

2. Better Naming Convention: Renaming raw-http → raw-request and handleRawHttpHandler → handleRawRequest better reflects the actual purpose, as these handle generic HTTP requests, not just a specific protocol.

3. Consistent Implementation: The type field is consistently added to all connection driver implementations:

   • http.ts: "http"
   • raw-request.ts: "raw-request"
   • raw-websocket.ts: "raw-websocket"
   • websocket.ts: "websocket"

4. Export Compatibility: The PR maintains backward compatibility by re-exporting handleRawWebSocket as handleRawWebSocketHandler in actor/mod.ts:93.

5. Debug Visibility: Exposing the connection type in getConnections() at actor/instance/mod.ts:142 improves observability for debugging.

Suggestions for Improvement 🔍

1. Type Safety for Connection Types

The type field is currently just a string. Consider using a string literal union type for better type safety:

export type ConnDriverType = 'http' | 'raw-request' | 'raw-websocket' | 'websocket';

export interface ConnDriver {
    /** The type of driver. Used for debug purposes only. */
    type: ConnDriverType;
    // ... rest of interface
}

This would:

• Prevent typos in driver implementations
• Enable better IDE autocomplete
• Make it easier to add new driver types in the future

2. Missing Export for handleRawRequest

The old handleRawHttpHandler function was renamed to handleRawRequest, but unlike handleRawWebSocket (which is re-exported as handleRawWebSocketHandler), there's no corresponding export or alias for handleRawRequest in actor/mod.ts.

If handleRawRequest is intended to be a public API, consider adding:

export {
    handleRawRequest,
    handleRawWebSocket as handleRawWebSocketHandler,
    handleWebSocketConnect,
} from "./router-endpoints";

3. Consistency in Function Naming

There's a naming inconsistency:

• handleRawRequest (uses "Request")
• handleRawWebSocket (uses "WebSocket")

For consistency, consider:

• Either: handleRawRequest + handleRawWebSocket (current)
• Or: handleRawHttp + handleRawWebSocket (more parallel structure)

The current naming is actually fine since "request" is more accurate than "http" (these are HTTP requests, not just HTTP in general).

4. Optional: Add Runtime Validation

Since the type field is critical for debugging, consider adding a simple assertion in the connection creation logic to ensure it's always set. This could catch bugs early if someone adds a new driver but forgets to set the type field.

Security & Performance ✅

• No security concerns: The changes are purely structural and don't introduce any new attack vectors.
• No performance impact: The type field is a simple string that's only used for debugging/observability.
• Memory overhead: Negligible (one additional string field per connection driver).

Test Coverage ⚠️

Recommendation: While this is a relatively low-risk change, consider adding a simple test to verify that all connection drivers have their type field properly set. For example:

// Verify all driver creation functions return a valid type
expect(createHttpSocket().type).toBe('http');
expect(createRawRequestSocket().type).toBe('raw-request');
expect(createWebSocketSocket(...).type).toBe('websocket');
expect(createRawWebSocketSocket(...).type).toBe('raw-websocket');

This would serve as documentation and prevent regression if someone modifies the drivers in the future.

Code Quality ✅

• Style: Changes follow the TypeScript conventions in the codebase
• Documentation: JSDoc comments are clear and helpful
• File organization: File rename (raw-http.ts → raw-request.ts) is appropriate
• Import updates: All import statements correctly updated

Final Verdict

Approve with minor suggestions ✅

The PR is well-executed and ready to merge. The suggestions above are optional improvements that could enhance type safety and maintainability, but they're not blockers. The core changes are sound and improve the codebase.

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/actor@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/cloudflare-workers@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/core@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/db@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/framework-base@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/next-js@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/react@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/rivetkit@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/sql-loader@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/engine-runner@3426

pnpm add https://pkg.pr.new/rivet-dev/rivet/@rivetkit/engine-runner-protocol@3426

commit: 1f30194

PR Review: Add conn type to RivetKit

Summary

This PR adds a type field to the ConnDriver interface for debugging purposes and renames createRawHttpSocket/handleRawHttpHandler to createRawRequestSocket/handleRawRequest for better semantic clarity.

✅ Positives

1. Better Naming Convention: The rename from raw-http to raw-request is semantically more accurate, as this driver handles general HTTP requests, not just raw HTTP connections.

2. Improved Debuggability: Adding the type field to ConnDriver will help with debugging connection issues and understanding which driver is being used in logs/inspections.

3. Good Documentation: The new fields have clear JSDoc comments explaining their purpose and usage.

4. Consistent Export Pattern: The export maintains backward compatibility by aliasing handleRawWebSocket as handleRawWebSocketHandler in src/actor/mod.ts:93.

🔍 Code Quality Observations

1. Type Field Usage: The type field is properly integrated into the connection inspection at src/actor/instance/mod.ts:142, making it accessible through getConnections().

2. All Driver Implementations Updated: All driver implementations correctly include the new type field:

   • http driver
   • raw-request driver (renamed)
   • raw-websocket driver
   • websocket driver

💡 Suggestions

1. Type Safety for Driver Types: Consider using a string literal union type for the type field instead of plain string to enforce valid driver types at compile time:

export type DriverType = 'http' | 'raw-request' | 'raw-websocket' | 'websocket';

export interface ConnDriver {
	/** The type of driver. Used for debug purposes only. */
	type: DriverType;
	// ... rest of interface
}

2. File Rename Completeness: The file was renamed from raw-http.ts to raw-request.ts, but verify that no documentation or comments elsewhere reference the old filename.

3. Test Coverage: While the changes are relatively straightforward, consider adding a test to verify:

   • The type field is correctly set for each driver type
   • The getConnections() method returns the correct type information

4. Deprecation Notice: If there are any external consumers using handleRawHttpHandler, consider adding a deprecation notice or checking for breaking changes in dependent packages.

🐛 Potential Issues

None identified - The changes are low-risk refactoring with good consistency across the codebase.

🔒 Security Considerations

No security concerns - this is purely internal metadata for debugging.

📊 Performance Considerations

Negligible impact - adding a string field has minimal memory overhead and is only used for debugging/inspection.

✅ Conclusion

This is a clean refactoring PR that improves code clarity and debuggability. The changes are well-executed with consistent updates across all affected files. The main improvement would be adding type safety to the type field with a union type.

Recommendation: Approve with minor suggestions

PR Review: Add conn type

Summary

This PR adds a type field to the ConnDriver interface for debugging purposes and performs some related refactoring, including renaming functions for consistency.

Code Quality ✅

Positives:

• Good documentation: The new type field and existing fields now have clear JSDoc comments explaining their purpose
• Consistent naming: The rename from handleRawWebSocketHandler → handleRawWebSocket and handleRawHttpHandler → handleRawRequest improves consistency
• The raw-http → raw-request file rename is more accurate since it handles generic HTTP requests

Improvements:

1. Type safety: Consider using a string literal union type instead of string for the type field to prevent typos:

   type ConnDriverType = 'http' | 'raw-request' | 'raw-websocket' | 'websocket';
   
   export interface ConnDriver {
     /** The type of driver. Used for debug purposes only. */
     type: ConnDriverType;
     // ...
   }

2. Optional type field: Since this is for debug purposes only, consider making it optional with type?: string to avoid breaking changes if new drivers are added. However, the current approach ensures all drivers explicitly declare their type.

Potential Issues 🔍

1. Missing export: The file rename raw-http.ts → raw-request.ts looks good, but verify that all exports are updated in any index files that might re-export this module.

2. Function name consistency: The function rename from createRawHttpSocket → createRawRequestSocket aligns well with the file rename.

Performance Considerations ⚡

No performance concerns. Adding a string field has negligible memory/performance impact.

Security Concerns 🔒

No security issues identified. The type field is for debugging only and doesn't expose sensitive information.

Test Coverage 🧪

Missing tests:

• No tests appear to verify the new type field is correctly set for each driver type
• Consider adding assertions in existing driver tests to verify:

  expect(conn[CONN_DRIVER_SYMBOL]?.type).toBe('websocket');

Test files that may need updates:

• tests/driver-engine.test.ts
• tests/driver-file-system.test.ts
• tests/driver-memory.test.ts

Additional Notes 📝

1. The getConnections method now returns the type field, which is useful for debugging connection states

2. All five driver types now have consistent type annotations:

   • http
   • raw-request
   • raw-websocket
   • websocket (assumed from context)

3. Consider adding the type field to any logging or error messages related to connections for better observability

Verdict ✅

Approved with minor suggestions. This is a clean refactoring that improves code clarity and debugging capabilities. The main suggestions are:

1. Consider using a string literal union type for type
2. Add test coverage for the new field
3. Optionally use the type field in logging for better observability

The changes are well-structured and maintain backward compatibility in terms of runtime behavior.

Code Review

Summary

This PR adds a type field to the ConnDriver interface for debugging purposes and renames raw-http to raw-request for better naming consistency. The changes are well-scoped and improve code clarity.

Positive Observations ✅

1. Good naming improvement: The rename from raw-http to raw-request better reflects the purpose since this driver handles HTTP requests specifically (as opposed to WebSocket connections)

2. Consistent implementation: The type field has been added to all driver implementations:

   • http
   • raw-request
   • raw-websocket
   • websocket

3. Proper documentation: Good JSDoc comments added to the new fields in the ConnDriver interface explaining their purpose

4. Debug utility: The type field is properly exposed in the getConnections() debug method (instance/mod.ts:142), which will help with troubleshooting

5. Comprehensive refactoring: All references to the old function names were updated:

   • handleRawWebSocketHandler → handleRawWebSocket
   • handleRawHttpHandler → handleRawRequest
   • File renamed: raw-http.ts → raw-request.ts

Potential Issues ⚠️

1. Breaking change consideration: The rename of handleRawWebSocketHandler is re-exported in the public API (actor/mod.ts:93):

   export {
       handleRawWebSocket as handleRawWebSocketHandler,
       handleWebSocketConnect,
   } from "./router-endpoints";

   While this maintains backward compatibility via aliasing, it's worth noting for any internal code that might directly import the non-aliased version.

2. Comment inconsistency in raw-request.ts: Line 5 says "Creates a raw HTTP connection driver" but the function is now called createRawRequestSocket(). Consider updating the comment to say "Creates a raw request connection driver" for consistency.

Minor Suggestions 💡

1. Type field documentation: While the comment says "Used for debug purposes only", consider being more explicit about what values are valid/expected. Perhaps add a union type or enum for the type field to make it type-safe:

   type DriverType = "http" | "raw-request" | "raw-websocket" | "websocket";
   
   export interface ConnDriver {
       type: DriverType;
       // ...
   }

2. Test coverage: I can see the test files exist (e.g., raw-http.ts, raw-http-request-properties.ts), but they weren't modified in this PR. Make sure these tests still pass with the function renaming, especially if they import the functions directly.

Security & Performance ✅

• No security concerns identified
• No performance impact - these are debug/metadata fields only

Conclusion

This is a solid refactoring PR that improves naming consistency and adds useful debugging information. The changes are well-implemented across all affected files. The main consideration is ensuring backward compatibility is maintained where needed and potentially adding type safety to the new type field.

Recommendation: Approve with minor suggestions for consideration.

Deployment failed with the following error:

Too many requests - try again in 1 minute (more than 120, code: "api-deployments-flood-pro").

Learn More: https://vercel.com/docs/limits#rate-limits

PR Review: Add Connection Type to ConnDriver

Summary

This PR adds a type field to the ConnDriver interface for debugging purposes and performs some related refactoring, including renaming functions for consistency.

✅ Positive Aspects

1. Good Documentation: The added JSDoc comments for type, requestId, requestIdBuf, and hibernatable fields improve code clarity significantly.

2. Consistent Naming: The rename from handleRawWebSocketHandler to handleRawWebSocket and createRawHttpSocket to createRawRequestSocket improves naming consistency:

   • Removes redundant "Handler" suffix
   • Aligns HTTP naming with "raw-request" which is more accurate for non-WebSocket requests

3. Proper Export Aliasing: The export in actor/mod.ts maintains backward compatibility:

   export { handleRawWebSocket as handleRawWebSocketHandler }

4. Safe Optional Access: The usage conn[CONN_DRIVER_SYMBOL]?.type properly handles cases where the driver might be undefined.

🔍 Code Quality Observations

1. Type Field Implementation: Each driver correctly implements the type field:

   • http
   • raw-request
   • raw-websocket
   • websocket

   These are descriptive and match their purpose.

2. Complete Refactoring: All references to the renamed functions have been updated across:

   • actor/router.ts
   • actor/router-endpoints.ts
   • actor/mod.ts
   • drivers/engine/actor-driver.ts
   • drivers/file-system/manager.ts

🤔 Considerations & Questions

1. Type Safety for type Field: Currently type is defined as string, which allows any value. Consider using a string union type or enum for better type safety:

   export type ConnDriverType = 'http' | 'raw-request' | 'raw-websocket' | 'websocket';
   
   export interface ConnDriver {
     type: ConnDriverType;
     // ...
   }

   This would prevent typos and provide autocomplete.

2. Debug-Only Field: The comment states "Used for debug purposes only." Consider whether this should be:

   • Excluded in production builds
   • Or if it might be useful for production debugging/observability

   If it's truly debug-only, you might want to document this more explicitly or consider conditional inclusion.

3. File Rename: The file raw-http.ts was renamed to raw-request.ts. While this is more accurate (since it handles HTTP requests, not just raw HTTP), ensure:

   • Any build scripts or tooling that might reference the old filename are updated
   • No hardcoded file paths exist elsewhere in the codebase

4. Testing: No test files were modified in this PR. Consider:

   • Are there tests that verify the type field is correctly set?
   • Are there tests for the renamed functions that need updating?
   • Should there be tests ensuring backward compatibility of the export alias?

🐛 Potential Issues

None identified - The changes appear correct and complete.

📊 Test Coverage

The PR doesn't include test updates. Recommendations:

• Add tests to verify each driver sets the correct type value
• Verify that getConnections() includes the type field in its output
• Test backward compatibility of the export alias if external consumers exist

🎯 Security & Performance

No concerns - This is a non-functional change that adds metadata for debugging. No security or performance implications identified.

✨ Overall Assessment

This is a clean, well-documented PR that improves code clarity and naming consistency. The changes are straightforward and complete. The main suggestion is to consider using a string union type for the type field to provide better type safety.

Recommendation: ✅ Approve with minor suggestions

Review generated by Claude Code

Merge activity

• Nov 13, 9:15 PM UTC: NathanFlurry added this pull request to the Graphite merge queue.
• Nov 13, 9:15 PM UTC: CI is running for this pull request on a draft pull request (#3465) due to your merge queue CI optimization settings.
• Nov 13, 9:16 PM UTC: Merged by the Graphite merge queue via draft PR: #3465.