147 lines
6.3 KiB
Python
147 lines
6.3 KiB
Python
"""JSON-RPC transport; native Codex owns reasoning, tools and conversation history."""
|
|
import asyncio
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
from .config import AUTH_MODE, CODEX_BIN, CODEX_HOME, MODEL, EFFORT, PROVIDER
|
|
|
|
|
|
def api_key():
|
|
key = os.environ.get('OPENAI_API_KEY', '').strip()
|
|
if not key and os.environ.get('OPENAI_API_KEY_FILE'):
|
|
try:
|
|
with Path(os.environ['OPENAI_API_KEY_FILE']).expanduser().open() as stream:
|
|
key = stream.read(16385).strip()
|
|
except (OSError, UnicodeError):
|
|
raise ValueError('Cannot read OPENAI_API_KEY_FILE') from None
|
|
if not key:
|
|
raise ValueError('PCB_CODEX_AUTH=apikey requires OPENAI_API_KEY or OPENAI_API_KEY_FILE')
|
|
if len(key) > 16384 or any(c.isspace() for c in key):
|
|
raise ValueError('OpenAI API key must be a single non-empty value')
|
|
return key
|
|
|
|
|
|
def process_config(production):
|
|
if AUTH_MODE not in {'apikey', 'chatgpt'}:
|
|
raise ValueError('PCB_CODEX_AUTH must be apikey or chatgpt')
|
|
config = {
|
|
'model': MODEL, 'model_provider': PROVIDER, 'model_reasoning_effort': EFFORT,
|
|
'approval_policy': 'never', 'web_search': 'live',
|
|
'sandbox_mode': 'workspace-write' if production else 'read-only',
|
|
'features.shell_tool': production, 'features.multi_agent': False,
|
|
'sandbox_workspace_write.network_access': True,
|
|
'sandbox_workspace_write.exclude_slash_tmp': True,
|
|
'sandbox_workspace_write.exclude_tmpdir_env_var': True,
|
|
'shell_environment_policy.ignore_default_excludes': False,
|
|
}
|
|
env = dict(os.environ, CODEX_HOME=str(CODEX_HOME))
|
|
for key in ('OPENAI_API_KEY', 'OPENAI_API_KEY_FILE', 'OPENAI_BASE_URL',
|
|
'DEEPSEEK_API_KEY', 'CODEX_API_KEY'):
|
|
env.pop(key, None)
|
|
if AUTH_MODE == 'apikey':
|
|
env['OPENAI_API_KEY'] = api_key()
|
|
prefix = 'model_providers.' + PROVIDER + '.'
|
|
config.update({
|
|
prefix + 'name': 'VibeMake OpenAI API',
|
|
prefix + 'base_url': 'https://api.openai.com/v1',
|
|
prefix + 'wire_api': 'responses',
|
|
prefix + 'env_key': 'OPENAI_API_KEY',
|
|
prefix + 'requires_openai_auth': False,
|
|
})
|
|
args = [CODEX_BIN, 'app-server', '--listen', 'stdio://']
|
|
for key, value in config.items():
|
|
args += ['-c', key + '=' + json.dumps(value)]
|
|
return args, env
|
|
|
|
|
|
class AppServer:
|
|
def __init__(self, directory, production, handler):
|
|
self.directory, self.production, self.handler = directory, production, handler
|
|
self.pending, self.requests, self.counter = {}, set(), 0
|
|
self.events = asyncio.Queue()
|
|
self.proc = None
|
|
self.reader = None
|
|
self.err = None
|
|
|
|
async def __aenter__(self):
|
|
args, env = process_config(self.production)
|
|
CODEX_HOME.mkdir(parents=True, exist_ok=True, mode=0o700)
|
|
self.err = (self.directory / 'codex-stderr.log').open('ab')
|
|
try:
|
|
self.proc = await asyncio.create_subprocess_exec(*args, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=self.err, env=env, cwd=self.directory, limit=64*1024*1024)
|
|
self.reader = asyncio.create_task(self._read())
|
|
await self.call('initialize', {'clientInfo': {'name':'vibemake_persistent_pcb','title':'VibeMake Persistent PCB','version':'1.0.0'}, 'capabilities':{'experimentalApi':True}})
|
|
await self.send({'method':'initialized'})
|
|
except BaseException:
|
|
await self.__aexit__()
|
|
raise
|
|
return self
|
|
|
|
async def send(self, message):
|
|
if self.proc.returncode is not None:
|
|
raise ConnectionError('Codex process exited')
|
|
self.proc.stdin.write((json.dumps(message, ensure_ascii=False)+'\n').encode())
|
|
await self.proc.stdin.drain()
|
|
|
|
async def call(self, method, params, timeout=90):
|
|
self.counter += 1
|
|
n = self.counter
|
|
future = asyncio.get_running_loop().create_future()
|
|
self.pending[n] = future
|
|
try:
|
|
await self.send({'id':n,'method':method,'params':params})
|
|
return await asyncio.wait_for(future, timeout)
|
|
finally:
|
|
self.pending.pop(n, None)
|
|
|
|
async def answer(self, msg):
|
|
try:
|
|
result = await self.handler(msg['method'], msg.get('params',{}))
|
|
await self.send({'id':msg['id'],'result':result})
|
|
except asyncio.CancelledError:
|
|
raise
|
|
except Exception as e:
|
|
await self.send({'id':msg['id'],'error':{'code':-32000,'message':str(e)}})
|
|
|
|
async def _read(self):
|
|
try:
|
|
while line := await self.proc.stdout.readline():
|
|
msg = json.loads(line)
|
|
if 'method' in msg and 'id' in msg:
|
|
job = asyncio.create_task(self.answer(msg))
|
|
self.requests.add(job)
|
|
job.add_done_callback(self.requests.discard)
|
|
elif 'method' in msg:
|
|
await self.events.put(msg)
|
|
elif msg.get('id') in self.pending:
|
|
future = self.pending[msg['id']]
|
|
if not future.done():
|
|
if 'error' in msg:
|
|
future.set_exception(RuntimeError(json.dumps(msg['error'],ensure_ascii=False)))
|
|
else:
|
|
future.set_result(msg.get('result'))
|
|
except Exception as e:
|
|
await self.events.put({'method':'transport/error','params':{'message':str(e)}})
|
|
finally:
|
|
for future in list(self.pending.values()):
|
|
if not future.done():
|
|
future.set_exception(ConnectionError('Codex transport ended'))
|
|
await self.events.put({'method':'transport/closed','params':{}})
|
|
|
|
async def __aexit__(self, *args):
|
|
for job in self.requests:
|
|
job.cancel()
|
|
await asyncio.gather(*self.requests, return_exceptions=True)
|
|
if self.proc and self.proc.returncode is None:
|
|
self.proc.terminate()
|
|
try:
|
|
await asyncio.wait_for(self.proc.wait(),10)
|
|
except asyncio.TimeoutError:
|
|
self.proc.kill()
|
|
await self.proc.wait()
|
|
if self.reader:
|
|
self.reader.cancel()
|
|
await asyncio.gather(self.reader,return_exceptions=True)
|
|
if self.err:
|
|
self.err.close()
|